下面列出了怎么用java.util.regex.Pattern的API类实例代码及写法,或者点击链接到github查看源代码。
public Movie parse(String path) {
Movie movie;
String fileName = File.baseName(path);
for(Pattern p : patternList) {
Matcher m = p.matcher(fileName);
if (m.find()) {
movie = new Movie();
movie.setMovieName(StringUtil.formatMatch(m.group(1)));
if(m.groupCount() == 4) {
movie.setYear(Integer.valueOf(m.group(2)));
movie.setQuality(m.group(3));
movie.setSource(VideoSources.getFormattedSource(m.group(4)));
} else if(m.groupCount() == 3) {
movie.setQuality(m.group(2));
movie.setSource(VideoSources.getFormattedSource(m.group(3)));
} else {
movie.setQuality(m.group(2));
}
return movie;
}
}
return null;
}
@Override
protected void replaceText(CharSequence text){
String beforeCursor = getText().toString().substring(0, getSelectionStart());
String afterCursor = getText().toString().substring(getSelectionStart());
Pattern pattern = Pattern.compile("#\\S*");
Matcher matcher = pattern.matcher(beforeCursor);
StringBuffer sb = new StringBuffer();
int matcherStart = 0;
while (matcher.find()) {
int curPos = getSelectionStart();
if(curPos > matcher.start() &&
curPos <= matcher.end()){
matcherStart = matcher.start();
matcher.appendReplacement(sb, text.toString()+" ");
}
}
matcher.appendTail(sb);
setText(sb.toString()+afterCursor);
setSelection(matcherStart + text.length()+1);
}
private static String resolveValue( Properties properties, String name ) {
String value = properties.getProperty( name );
Pattern pattern = Pattern.compile( ".*?(\\$\\{)(.*?)(\\}).*" );
Matcher matcher = pattern.matcher( value );
while( matcher.matches() ) {
StringBuilder resolvedValue = new StringBuilder( value.length() );
resolvedValue.append( value.substring( 0, matcher.start( 1 ) ) );
String varName = matcher.group( 2 );
String varVal = properties.getProperty( varName );
if( varVal != null ) {
resolvedValue.append( varVal );
}
resolvedValue.append( value.substring( matcher.end( 3 ) ) );
value = resolvedValue.toString();
matcher = pattern.matcher( value );
}
return value;
}
void check(String out, int count) {
System.err.println(out);
Pattern warn = Pattern.compile("warning - @param argument \"i[0-9]+\" is not a parameter name");
Matcher m = warn.matcher(out);
int n = 0;
for (int start = 0; m.find(start); start = m.start() + 1) {
n++;
}
if (n != count)
error("unexpected number of warnings reported: " + n + "; expected: " + count);
Pattern warnCount = Pattern.compile("(?ms).*^([0-9]+) warnings$.*");
m = warnCount.matcher(out);
if (m.matches()) {
n = Integer.parseInt(m.group(1));
if (n != count)
error("unexpected number of warnings reported: " + n + "; expected: " + count);
} else
error("total count not found");
}
private static List<String> sparkClasspath() {
String sparkJars = System.getProperty("spark.jars");
Pattern isKotlinJar = Pattern.compile("/kotlin-[a-z]*(-.*)?\\.jar");
Stream<File> addedJars = Arrays.stream(Utils.resolveURIs(sparkJars).split(","))
.filter(s -> !s.trim().equals(""))
.filter(s -> !isKotlinJar.matcher(s).find())
.map(s -> {
int p = s.indexOf(':');
return new File(s.substring(p + 1));
});
Stream<File> systemJars = Arrays.stream(
System.getProperty("java.class.path").split(File.pathSeparator))
.map(File::new);
return Stream.concat(addedJars, systemJars)
.map(file -> {
try {
return file.getCanonicalPath();
} catch (IOException e) {
return "";
}
})
.collect(Collectors.toList());
}
/**
* 邮箱格式是否正确
*
* @param email
* @return
*/
public static boolean isEmail(String email) {
if (TextUtils.isEmpty(email))
return false;
String expression = "^[\\w\\.-][email protected]([\\w\\-]+\\.)+[A-Z]{2,4}$";
Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(email);
if (matcher.matches())
return true;
else
return false;
}
/**
* Extract class from inline variables
*
* {# @var \AppBundle\Entity\Foo variable #}
* {# @var variable \AppBundle\Entity\Foo #}
*/
@NotNull
private Collection<PhpClass> getVarClassGoto(@NotNull PsiElement psiElement) {
String comment = psiElement.getText();
if(StringUtils.isBlank(comment)) {
return Collections.emptyList();
}
for(String pattern: TwigTypeResolveUtil.DOC_TYPE_PATTERN_SINGLE) {
Matcher matcher = Pattern.compile(pattern).matcher(comment);
if (matcher.find()) {
String className = matcher.group("class");
if(StringUtils.isNotBlank(className)) {
return PhpElementsUtil.getClassesInterface(psiElement.getProject(), className);
}
}
}
return Collections.emptyList();
}
List<String> quotedStringToList(String subjectString) {
List<String> matchList = new ArrayList<String>();
Pattern regex = Pattern.compile("[^\\s\"']+|\"([^\"]*)\"|'([^']*)'");
Matcher regexMatcher = regex.matcher(subjectString);
while (regexMatcher.find()) {
if (regexMatcher.group(1) != null) {
// Add double-quoted string without the quotes
matchList.add(regexMatcher.group(1));
} else if (regexMatcher.group(2) != null) {
// Add single-quoted string without the quotes
matchList.add(regexMatcher.group(2));
} else {
// Add unquoted word
matchList.add(regexMatcher.group());
}
}
return matchList;
}
private Query createRegexQuery ( QueryDef qd ) {
BooleanQuery query = new BooleanQuery();
List<SpanQuery> spanClausesList = new ArrayList<SpanQuery>();
String[] queryStrings;
SpanQuery[] spanClausesArray;
RegexQuery regexQuery;
for ( String fld : qd.fields ) {
spanClausesList.clear();
queryStrings = qd.query.split(" ");
spanClausesArray = new SpanQuery[queryStrings.length];
for ( String subquery : queryStrings ) {
regexQuery = new RegexQuery( new Term( fld, subquery ) );
regexQuery.setRegexImplementation( new JavaUtilRegexCapabilities() );
//if emptyable, like a query '(optional)?' or 'bla|a*', make span optional by wrapping it SpanOrQuery
if(Pattern.matches(subquery, "")){
spanClausesList.add( new SpanOrQuery( new SpanMultiTermQueryWrapper<RegexQuery>( regexQuery ) ) );
} else {
spanClausesList.add( new SpanMultiTermQueryWrapper<RegexQuery>( regexQuery ) );
}
}
spanClausesList.toArray( spanClausesArray );
query.add( new SpanNearQuery( spanClausesArray, 0, true), Occur.SHOULD );
}
return query;
}
/**
* Returns a list with all links contained in the input
*/
public static List<String> extractUrls(String text)
{
List<String> containedUrls = new ArrayList<String>();
String urlRegex = "((https?|ftp|gopher|telnet|file):((//)|(\\\\))+[\\w\\d:#@%/;$()~_?\\+-=\\\\\\.&]*)";
Pattern pattern = Pattern.compile(urlRegex, Pattern.CASE_INSENSITIVE);
Matcher urlMatcher = pattern.matcher(text);
while (urlMatcher.find())
{
containedUrls.add(text.substring(urlMatcher.start(0),
urlMatcher.end(0)));
}
return containedUrls;
}
@Test(dataProvider="schemagenGenerationData")
public void schemangenGenerationTestCase(String shortTestName,
String inputFileName, String regexp) throws IOException {
//Create test case directory
Path testCaseDir = testWorkDir.resolve(shortTestName);
Files.createDirectories(testCaseDir);
//Copy java source from test.src to the test case dir
Files.copy(testSrcDir.resolve(inputFileName), testCaseDir.resolve(inputFileName), REPLACE_EXISTING);
//Run schemagen
runSchemaGen(inputFileName, testCaseDir);
//Check if schema file generated
Assert.assertTrue(Files.exists(testCaseDir.resolve(SCHEMA_FILE)));
//Read schema content from file
String content = Files.lines(testCaseDir.resolve(SCHEMA_FILE)).collect(Collectors.joining(""));
System.out.println("Generated schema: " + content);
//Check if schema contains expected content
Assert.assertTrue(Pattern.matches(regexp, content));
}
/**
*
* @param message
*/
public static AsrResult parseAsrResult(String id,String message , int speakms) {
AsrResult asrResult = null ;
Pattern pattern = Pattern.compile("([\\d]{1,})[\\.]{1}([\\s\\S]*);");
Matcher matcher = pattern.matcher(message);
if(matcher.find() && matcher.groupCount() == 2) {
asrResult = new AsrResult(id , matcher.group(2) , matcher.group(1));
if(asrResult.getMessage().endsWith("。")) {
asrResult.setMessage(asrResult.getMessage().substring(0 , asrResult.getMessage().length() - 1));
}
}
if(speakms > 0 && asrResult!=null) {
asrResult.setSpeakms(speakms);
}
return asrResult;
}
private static Map<String, String> getInlineCommentDocsVars(@NotNull PsiElement twigCompositeElement) {
Map<String, String> variables = new HashMap<>();
for(PsiElement psiComment: YamlHelper.getChildrenFix(twigCompositeElement)) {
if(!(psiComment instanceof PsiComment)) {
continue;
}
String text = psiComment.getText();
if(StringUtils.isBlank(text)) {
continue;
}
for (Pattern pattern : INLINE_DOC_REGEX) {
Matcher matcher = pattern.matcher(text);
while (matcher.find()) {
variables.put(matcher.group("var"), matcher.group("class"));
}
}
}
return variables;
}
/**
* 正则替换指定值<br>
* 通过正则查找到字符串,然后把匹配到的字符串加入到replacementTemplate中,$1表示分组1的字符串
*
* @param content 文本
* @param pattern {@link Pattern}
* @param replacementTemplate 替换的文本模板,可以使用$1类似的变量提取正则匹配出的内容
* @return 处理后的文本
* @since 3.0.4
*/
public static String replaceAll(String content, Pattern pattern, String replacementTemplate) {
if (StrUtil.isEmpty(content)) {
return content;
}
final Matcher matcher = pattern.matcher(content);
boolean result = matcher.find();
if (result) {
final Set<String> varNums = findAll(PatternPool.GROUP_VAR, replacementTemplate, 1, new HashSet<String>());
final StringBuffer sb = new StringBuffer();
do {
String replacement = replacementTemplate;
for (String var : varNums) {
int group = Integer.parseInt(var);
replacement = replacement.replace("$" + var, matcher.group(group));
}
matcher.appendReplacement(sb, escape(replacement));
result = matcher.find();
} while (result);
matcher.appendTail(sb);
return sb.toString();
}
return content;
}
public static boolean renameDict(final File dictFile, final File newDictFile) {
if (dictFile.isFile()) {
return dictFile.renameTo(newDictFile);
} else if (dictFile.isDirectory()) {
final String dictName = dictFile.getName();
final String newDictName = newDictFile.getName();
if (newDictFile.exists()) {
return false;
}
for (final File file : dictFile.listFiles()) {
if (!file.isFile()) {
continue;
}
final String fileName = file.getName();
final String newFileName = fileName.replaceFirst(
Pattern.quote(dictName), Matcher.quoteReplacement(newDictName));
if (!file.renameTo(new File(dictFile, newFileName))) {
return false;
}
}
return dictFile.renameTo(newDictFile);
}
return false;
}
public static Matcher<String> matchingPattern(String patternStr) {
return new TypeSafeDiagnosingMatcher<String>() {
@Override
protected boolean matchesSafely(String text, Description mismatchDescription) {
Pattern pattern = Pattern.compile(patternStr, Pattern.DOTALL);
boolean matches = pattern.matcher(text).matches();
if (!matches) {
mismatchDescription.appendText(text);
}
return matches;
}
@Override
public void describeTo(Description description) {
description.appendText("matching '" + patternStr + "'");
}
};
}
private String convertType(String type) {
Matcher matcher;
for (CoTTypeDef cd : this.coTTypeMap) {
if (!cd.isPredicate()) {
Pattern pattern = Pattern.compile(cd.getKey());
matcher = pattern.matcher(type);
if (matcher.find()) {
return this.filterOutDots(appendToType(type)
+ cd.getValue());
}
}
}
// no match was found
return "";
}
/**
* Tests that searching currencies by regex is supported.
*/
@Test
public void testSeachByRegex() {
String dollarRegex = "\\p{Upper}{2}D";
Pattern dollarPattern = Pattern.compile(dollarRegex);
Collection<CurrencyUnit> allCurrencies = Monetary.getCurrencies(CurrencyQueryBuilder.of().build());
Set<String> availableDollarCodes = allCurrencies.stream()
.map(CurrencyUnit::getCurrencyCode)
.filter(currencyCode -> dollarPattern.matcher(currencyCode).matches())
.collect(toSet());
assertFalse(availableDollarCodes.isEmpty());
CurrencyQuery dollarQuery = CurrencyQueryBuilder.of().setCurrencyCodes(dollarRegex).build();
Collection<CurrencyUnit> dollarCurrencies = Monetary.getCurrencies(dollarQuery);
for (CurrencyUnit dollarCurrency : dollarCurrencies) {
availableDollarCodes.remove(dollarCurrency.getCurrencyCode());
}
assertTrue(availableDollarCodes.isEmpty());
}
private void processMatches(Pattern pattern, byte[] content, boolean isRequest){
final Matcher respMatcher = pattern.matcher(new String(content));
while(respMatcher.find() && !Thread.currentThread().isInterrupted()){
String[] groups = new String[respMatcher.groupCount()+1];
for (int i = 0; i < groups.length; i++) {
groups[i] = respMatcher.group(i);
}
if(isRequest) {
requestMatches++;
}else {
responseMatches++;
}
results.add(new Match(groups, isRequest));
}
}
private Func1<String, Boolean> tagNameFilter(String regexp) {
if(regexp != null) {
boolean positive = (!regexp.startsWith("!"));
Pattern p = PatternUtil.filterPattern(regexp);
return s -> positive == p.matcher(s).matches(); // XNOR
}
return s -> true;
}
public static String RegexFind(String regex,String string,int start,int end){
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(string);
String res = string;
while (matcher.find()){
res = matcher.group();
}
return res.substring(start, res.length() - end);
}
private String findXmlElementText(String xmlMsg, String elementName)
{
Pattern pattern = Pattern.compile(".*<" + elementName + ">(.*)</" + elementName + ">.*");
Matcher matcher = pattern.matcher(xmlMsg);
if (matcher.matches() && matcher.groupCount() == 1)
{
return matcher.group(1);
}
else
{
return null;
}
}
/**
* A topic survives if (1) it doesn't match the blacklist, and
* (2) either whitelist is empty, or it matches the whitelist.
* Whitelist and blacklist use regex patterns (NOT glob patterns).
*/
public static boolean survived(String topic, List<Pattern> blacklist, List<Pattern> whitelist) {
if (stringInPatterns(topic, blacklist)) {
return false;
}
return (whitelist.isEmpty() || stringInPatterns(topic, whitelist));
}
@Override
@Deprecated
public <T extends TCSObject<T>> Set<T> getTCSObjects(Class<T> clazz,
Pattern regexp)
throws CredentialsException {
LOG.debug("method entry");
return kernelState.getTCSObjects(clazz, regexp);
}
public static int countOccurences(String dotText, String label) {
final Pattern pattern = Pattern.compile(label, Pattern.MULTILINE);
Matcher matcher = pattern.matcher(dotText);
int count = 0;
while (matcher.find()) {
count++;
}
return count;
}
public KibanaUtils(final PluginSettings settings, final PluginClient pluginClient) {
this.pluginClient = pluginClient;
this.projectPrefix = StringUtils.isNotBlank(settings.getCdmProjectPrefix()) ? settings.getCdmProjectPrefix() : "";
this.reIndexPattern = Pattern.compile("^" + projectPrefix + "\\.(?<name>[a-zA-Z0-9-]*)\\.(?<uid>.*)\\.\\*$");
this.reProjectFromIndex = Pattern.compile("^(" + projectPrefix + ")?\\.(?<name>[a-zA-Z0-9-]*)(\\.(?<uid>.*))?\\.\\d{4}\\.\\d{2}\\.\\d{2}$");
this.defaultVersion = Version.valueOf(ConfigurationSettings.DEFAULT_KIBANA_VERSION);
}
private Pattern wildcardToRegex(String filter) {
String trimmed = filter.trim();
if (trimmed.isEmpty()) {
return null;
}
String regex = (trimmed.contains("*") ? "^" : "") + "\\Q"//$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+ trimmed.replaceAll("\\*", //$NON-NLS-1$
Matcher.quoteReplacement("\\E.*?\\Q")) //$NON-NLS-1$
+ "\\E";//$NON-NLS-1$
// remove potentially empty quotes at begin or end
regex = regex.replaceAll(Pattern.quote("\\Q\\E"), ""); //$NON-NLS-1$ //$NON-NLS-2$
return Pattern.compile(regex);
}
private void hitEndTest(boolean callFind, String testNo, String regex,
String input, boolean hit) {
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
if (callFind) {
matcher.find();
} else {
matcher.matches();
}
boolean h = matcher.hitEnd();
assertTrue(testNo, h == hit);
}
/**
* Parses group header data.
*
* @param group EdmEntity representing group.
* @param groupData Group data to parse.
* @param endGroupPosition Position where "endGroup" statement is. Used for parsing data between "endGroup" and "endObjectProperties"
* @return Data without parsed section.
* @throws EdmException if an error occurs.
*/
private StringBuilder parseGroupHeader(EdmEntity group, StringBuilder groupData, int endGroupPosition) throws EdmException {
// group data between "endGroup" and "endObjectProperties" declaration
int afterDataStart = endGroupPosition + 8; // 8 = "endGroup".length
int afterDataEnd = groupData.length() - 19; // 19 = "endObjectProperties".length
String afterData = groupData.substring(afterDataStart, afterDataEnd);
// removes afterData from groupData
groupData.delete(endGroupPosition, groupData.length());
// group data between "beginObjectProperties" and "beginGroup" declaration
Pattern p = Pattern.compile(
"(object\\s+activeGroupClass.*?beginObjectProperties(.*?)beginGroup)",
Pattern.DOTALL);
Matcher m = p.matcher(groupData);
m.find();
int start = m.start();
int end = m.end();
String matchData = m.group(2);
// append afterData
matchData = matchData + afterData;
Pattern p1 = Pattern.compile(".*");
Matcher m1 = p1.matcher(matchData);
while (m1.find())
parseProperty(m1, group);
groupData.delete(start, end);
return groupData;
}
/**
* Creates a test channel including all the modular packages served by this mock class.
*
* In addition, the channel includes also the 'perl-5.26.3' package, which is part of 'perl:5.26' module definition,
* but served as a regular package.
*
* @param user the user to create the channel with
* @return a populated test channel
*/
public static Channel createModularTestChannel(User user) throws Exception {
Channel channel = TestUtils.reload(ChannelFactoryTest.createTestChannel(user, "channel-x86_64"));
channel.setChecksumType(ChannelFactory.findChecksumTypeByLabel("sha1"));
Modules modulemd = new Modules();
modulemd.setChannel(channel);
modulemd.setRelativeFilename("/path/to/modulemd.yaml");
channel.setModules(modulemd);
List<String> nevras = doGetAllPackages();
// perl 5.26 is a special package which is included in the module definition even though it's not served as a
// modular package. We need it in the channel to be able to test this case.
String perlNevra = "perl-5.26.3-416.el8:4.x86_64";
nevras.add(perlNevra);
// 'modularitylabel' rpm tag determines that a package belongs to a module
PackageExtraTagsKeys modularityHeader = PackageManagerTest.createExtraTagKey("modularitylabel");
Pattern nevraPattern = Pattern.compile("^(.*)-(\\d+):(.*)-(.*)\\.(.*)$");
for (String nevra : nevras) {
Matcher m = nevraPattern.matcher(nevra);
if (m.matches()) {
Package pkg = PackageTest.createTestPackage(user.getOrg());
PackageTest.populateTestPackage(pkg, user.getOrg(), PackageNameTest.createTestPackageName(m.group(1)),
PackageEvrFactoryTest.createTestPackageEvr(m.group(2), m.group(3), m.group(4)),
PackageFactory.lookupPackageArchByLabel(m.group(5)));
if (!perlNevra.equals(nevra)) {
// Exclude non-modular Perl package mentioned above
pkg.setExtraTags(Collections.singletonMap(modularityHeader, "my:nsvc"));
}
channel.addPackage(pkg);
}
}
ChannelFactory.save(channel);
return channel;
}