下面列出了怎么用java.util.regex.MatchResult的API类实例代码及写法，或者点击链接到github查看源代码。
public static String substituteTemplate(final IContext context, String template,
final IMendixObject substitute, final boolean HTMLEncode, final String datetimeformat) {
return regexReplaceAll(template, "\\{(@)?([\\w./]+)\\}", (MatchResult match) -> {
String value;
String path = match.group(2);
if (match.group(1) != null)
value = String.valueOf(Core.getConfiguration().getConstantValue(path));
else {
try
{
value = ORM.getValueOfPath(context, substitute, path, datetimeformat);
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
return HTMLEncode ? HTMLEncode(value) : value;
});
}
private int parseYear(Scanner s, int defaultYear) {
if (s.hasNext(YEAR)) {
s.next(YEAR);
MatchResult mr = s.match();
if (mr.group(1) != null) {
return 1900; // systemv has min
} else if (mr.group(2) != null) {
return YEAR_MAX_VALUE;
} else if (mr.group(3) != null) {
return defaultYear;
}
return Integer.parseInt(mr.group(4));
/*
if (mr.group("min") != null) {
//return YEAR_MIN_VALUE;
return 1900; // systemv has min
} else if (mr.group("max") != null) {
return YEAR_MAX_VALUE;
} else if (mr.group("only") != null) {
return defaultYear;
}
return Integer.parseInt(mr.group("year"));
*/
}
throw new IllegalArgumentException("Unknown year: " + s.next());
}
private int parseYear(Scanner s, int defaultYear) {
if (s.hasNext(YEAR)) {
s.next(YEAR);
MatchResult mr = s.match();
if (mr.group(1) != null) {
return 1900; // systemv has min
} else if (mr.group(2) != null) {
return YEAR_MAX_VALUE;
} else if (mr.group(3) != null) {
return defaultYear;
}
return Integer.parseInt(mr.group(4));
/*
if (mr.group("min") != null) {
//return YEAR_MIN_VALUE;
return 1900; // systemv has min
} else if (mr.group("max") != null) {
return YEAR_MAX_VALUE;
} else if (mr.group("only") != null) {
return defaultYear;
}
return Integer.parseInt(mr.group("year"));
*/
}
throw new IllegalArgumentException("Unknown year: " + s.next());
}
public Map<String,String> parse(String str) {
if ( !matches(str) ) {
throw new IllegalArgumentException(String.format("[%s] doesn't match pattern [%s]", str, m_pattern));
}
Scanner scanner = new Scanner(str);
scanner.findWithinHorizon(m_regex, 0);
MatchResult result = scanner.match();
Map<String,String> vals = new HashMap<String,String>();
if ( result.groupCount()!=m_nameList.size() ) {
// this shouldn't be able to happen
throw new IllegalStateException(String.format("[%s] doesn't match pattern [%s]; found %d matches, expected %d", str, m_pattern, result.groupCount(), m_nameList.size()));
}
for (int i=1; i<=result.groupCount(); i++) {
String name = m_nameList.get(i-1);
String val = result.group(i);
if ( vals.containsKey(name) ) {
if ( !vals.get(name).equals(val) ) {
throw new IllegalArgumentException(String.format("[%s]doesnt match pattern [%s]; variable [%s] has values [%s] and [%s]", str, m_pattern, name, val, vals.get(name)));
}
}
vals.put(name,result.group(i));
}
return vals;
}
private Map<String, String> parseResponseHeaders(final Scanner scanner) throws BatchException {
Map<String, String> headers = new HashMap<String, String>();
while (scanner.hasNext() && !scanner.hasNext(REG_EX_BLANK_LINE)) {
if (scanner.hasNext(REG_EX_HEADER)) {
scanner.next(REG_EX_HEADER);
currentLineNumber++;
MatchResult result = scanner.match();
if (result.groupCount() == 2) {
String headerName = result.group(1).trim();
String headerValue = result.group(2).trim();
if (BatchHelper.HTTP_CONTENT_ID.equalsIgnoreCase(headerName)) {
if (currentContentId == null) {
currentContentId = headerValue;
}
} else {
headers.put(headerName, headerValue);
}
}
} else {
currentLineNumber++;
throw new BatchException(BatchException.INVALID_HEADER.addContent(scanner.next()).addContent(currentLineNumber));
}
}
return headers;
}
private int parseYear(Scanner s, int defaultYear) {
if (s.hasNext(YEAR)) {
s.next(YEAR);
MatchResult mr = s.match();
if (mr.group(1) != null) {
return 1900; // systemv has min
} else if (mr.group(2) != null) {
return YEAR_MAX_VALUE;
} else if (mr.group(3) != null) {
return defaultYear;
}
return Integer.parseInt(mr.group(4));
/*
if (mr.group("min") != null) {
//return YEAR_MIN_VALUE;
return 1900; // systemv has min
} else if (mr.group("max") != null) {
return YEAR_MAX_VALUE;
} else if (mr.group("only") != null) {
return defaultYear;
}
return Integer.parseInt(mr.group("year"));
*/
}
throw new IllegalArgumentException("Unknown year: " + s.next());
}
/**
* Search from same startIndex as the previous search.
* Checks if the match is different from the last (either
* extended/reduced) at the same position. Returns true
* if the current match result represents a different match
* than the last, false if no match or the same.
*/
private boolean foundExtendedMatch(Pattern pattern, int start) {
if (pattern.pattern().equals(lastRegex)) {
return false;
}
int length = target.getDocument().getLength() - start;
try {
target.getDocument().getText(start, length, segment);
} catch (BadLocationException e) {
e.printStackTrace();
}
Matcher matcher = pattern.matcher(segment.toString());
MatchResult matchResult = getMatchResult(matcher, true);
if (matchResult != null) {
if ((matchResult.start() == 0) && (!lastMatchResult.group().equals(matchResult.group()))) {
updateStateAfterFound(matchResult, start);
return true;
}
}
return false;
}
private static MatchResult matchSystemFile(final String pSystemFile, final String pPattern, final int pHorizon) throws SystemUtilsException {
InputStream in = null;
try {
final Process process = new ProcessBuilder(new String[] {"/system/bin/cat", pSystemFile}).start();
in = process.getInputStream();
final Scanner scanner = new Scanner(in);
final boolean matchFound = scanner.findWithinHorizon(pPattern, pHorizon) != null;
if (matchFound) {
return scanner.match();
} else {
throw new SystemUtilsException();
}
} catch (final IOException e) {
throw new SystemUtilsException(e);
} finally {
StreamUtils.close(in);
}
}
private int parseYear(Scanner s, int defaultYear) {
if (s.hasNext(YEAR)) {
s.next(YEAR);
MatchResult mr = s.match();
if (mr.group(1) != null) {
return 1900; // systemv has min
} else if (mr.group(2) != null) {
return YEAR_MAX_VALUE;
} else if (mr.group(3) != null) {
return defaultYear;
}
return Integer.parseInt(mr.group(4));
/*
if (mr.group("min") != null) {
//return YEAR_MIN_VALUE;
return 1900; // systemv has min
} else if (mr.group("max") != null) {
return YEAR_MAX_VALUE;
} else if (mr.group("only") != null) {
return defaultYear;
}
return Integer.parseInt(mr.group("year"));
*/
}
throw new IllegalArgumentException("Unknown year: " + s.next());
}
public String createURI(final Map<String, String> values) {
Preconditions.checkNotNull(values);
Preconditions.checkArgument(values.keySet().equals(new HashSet<String>(paramNames)), "Incomplete set of values for path " + pathString + ", expected the following keys: " + paramNames + ", found: " + values.keySet());
return regexReplaceAll(pathString, PARAMNAME_REGEX, new Function<MatchResult, String>() {
@Override
public String apply(MatchResult match) {
String paramName = match.group(1);
String value = values.get(paramName);
if (value == null || value.isEmpty()) {
throw new IllegalArgumentException("No value was defined for path element '{" + paramName + "}'. The value should be non-empty.");
}
return Utils.urlEncode(values.get(paramName));
}
});
}
public static GroupId ofString(String str) {
Matcher matcher = VERSION_PATTERN.matcher(str);
if (matcher.matches()) {
MatchResult result = matcher.toMatchResult();
return GroupId.of(
result.group(1),
Optional.ofNullable(result.group(2)).map(Integer::parseInt)
);
} else {
return GroupId.of(
str,
Optional.empty()
);
}
}
@Override
public boolean matches(final Context context) {
checkNotNull(context);
String path = context.getRequest().getPath();
log.debug("Matching: {}~={}", path, pattern);
final java.util.regex.Matcher m = pattern.matcher(path);
if (m.matches()) {
// expose match result in context
context.getAttributes().set(State.class, new State()
{
@Override
public MatchResult getMatchResult() {
return m;
}
});
return true;
}
// no match
return false;
}
/**
* 引数の文字列をラクダ記法（単語区切りが大文字）とみなして、
* それを全て大文字のスネーク記法（単語区切りがアンダースコア）に変換します。
* 例えば、ラクダ記法の<code>tigerSupportApi</code>は、
* スネーク記法の<code>TIGER_SUPPORT_API</code>に変換されます。
* @param camel ラクダ記法の文字列
* @return スネーク記法（全て大文字）
*/
public static String toSnake(String camel) {
if (Strings.isBlank(camel))
return "";
ArrayList<String> words = new ArrayList<String>();
Matcher matcher = SNAKE_CASE_WORD.matcher(camel);
while(matcher.find()) {
MatchResult result = matcher.toMatchResult();
String word = camel.substring(result.start(), result.end());
words.add(word.toUpperCase());
}
return Strings.joinBy("_", words);
}
private int parseYear(Scanner s, int defaultYear) {
if (s.hasNext(YEAR)) {
s.next(YEAR);
MatchResult mr = s.match();
if (mr.group(1) != null) {
return 1900; // systemv has min
} else if (mr.group(2) != null) {
return YEAR_MAX_VALUE;
} else if (mr.group(3) != null) {
return defaultYear;
}
return Integer.parseInt(mr.group(4));
/*
if (mr.group("min") != null) {
//return YEAR_MIN_VALUE;
return 1900; // systemv has min
} else if (mr.group("max") != null) {
return YEAR_MAX_VALUE;
} else if (mr.group("only") != null) {
return defaultYear;
}
return Integer.parseInt(mr.group("year"));
*/
}
throw new IllegalArgumentException("Unknown year: " + s.next());
}
private int parseYear(Scanner s, int defaultYear) {
if (s.hasNext(YEAR)) {
s.next(YEAR);
MatchResult mr = s.match();
if (mr.group(1) != null) {
return 1900; // systemv has min
} else if (mr.group(2) != null) {
return YEAR_MAX_VALUE;
} else if (mr.group(3) != null) {
return defaultYear;
}
return Integer.parseInt(mr.group(4));
/*
if (mr.group("min") != null) {
//return YEAR_MIN_VALUE;
return 1900; // systemv has min
} else if (mr.group("max") != null) {
return YEAR_MAX_VALUE;
} else if (mr.group("only") != null) {
return defaultYear;
}
return Integer.parseInt(mr.group("year"));
*/
}
throw new IllegalArgumentException("Unknown year: " + s.next());
}
/**
* Build a group dictionary from the matched groups. <br>
* Guaranteed to contain 4 keys:<br>
* <ol>
* <li><tt>FormatString</tt>: the complete format string part</li>
* <li><tt>StringCharacter</tt>: the literal delimiter used (e.g. <tt>",',''',"""</tt></li>
* <li><tt>InterpolantToken</tt>: the percent sign, used to signal string interpolation</li>
* <li><tt>InterpolationValues</tt>: the values for filling in the specifier tokens in the format string.</li>
* </ol>
* @param matchResult
* @return the K, V mapped groups.
* @see {@link #FMTSTR_PATTERN}
*/
private static Map<String, String> extractFormatStringGroups(final MatchResult matchResult) {
// in a strict sense the assertion here is superfluous since the enclosing
// context in the caller already does a check if the group count is 4 and
// the execution branch in which this method is called will not be run if
// it isn't 4.
Assert.isLegal(4 == matchResult.groupCount(),
"E: Match result from FMTSTR_PATTERN is malformed. Group count must be 4.");
final Map<String, String> result = new HashMap<String, String>(4);
final String fmtString = matchResult.group(1);
final String strChar = matchResult.group(2);
final String interpToken = matchResult.group(3);
final String interpValues = matchResult.group(4);
result.put("FormatString", fmtString);
result.put("StringCharacter", strChar);
result.put("InterpolantToken", interpToken);
result.put("InterpolationValues", interpValues);
return result;
}
private String substitute(MatchResult matcher) {
StringBuilder rewrittenUrl = new StringBuilder();
// There may not be enough literals to fully interleave with placeholders.
// This is just how String.split(REGEX) works.
// Any remaining literals are assumed to be empty strings.
for (int i = 0; i < placeholderNumbers.size(); i++) {
if (literals.size() > i) {
rewrittenUrl.append(literals.get(i));
}
rewrittenUrl.append(matcher.group(placeholderNumbers.get(i)));
}
if (literals.size() > placeholderNumbers.size()) {
rewrittenUrl.append(literals.get(literals.size() - 1));
}
return rewrittenUrl.toString();
}
protected ThreadStack parseThreadInfo(String threadInfo) {
Scanner s = new Scanner(threadInfo);
ThreadStack result = new ThreadStack();
// parsing thread info
s.findInLine(threadInfoPattern());
MatchResult res = s.match();
result.setThreadName(res.group(1));
result.setType(res.group(3));
result.setPriority(res.group(4));
result.setTid(res.group(7));
result.setNid(res.group(8));
result.setStatus(res.group(9));
s.close();
return result;
}
protected MethodInfo parseMethodInfo(String line) {
MethodInfo result = new MethodInfo();
Scanner s = new Scanner(line);
s.findInLine(methodInfoPattern());
MatchResult rexp = s.match();
if (rexp.group(4) != null && rexp.group(4).length() > 0) {
// line " at tmtools.jstack.share.utils.Utils.sleep(Utils.java:29)"
result.setName(rexp.group(1));
result.setCompilationUnit(rexp.group(2));
result.setLine(rexp.group(4));
} else {
// line " at java.lang.Thread.sleep(Native Method)"
result.setName(rexp.group(1));
}
s.close();
return result;
}
private void parseMessage(){
Scanner scanner = new Scanner(getMessage());
while(scanner.hasNextLine()){
//check of --variable APP_ID=value is needed
if( scanner.findInLine("(?:\\s\\-\\-variable\\s(\\w*)=value)") != null ){
MatchResult mr = scanner.match();
StringBuilder missingVars = new StringBuilder();
for(int i = 0; i<mr.groupCount();i++){
if(i>0){
missingVars.append(",");
}
missingVars.append(mr.group());
}
pluginStatus = new HybridMobileStatus(IStatus.ERROR, HybridCore.PLUGIN_ID, CordovaCLIErrors.ERROR_MISSING_PLUGIN_VARIABLE,
NLS.bind("This plugin requires {0} to be defined",missingVars), null);
}
scanner.nextLine();
}
scanner.close();
}
private int parseYear(Scanner s, int defaultYear) {
if (s.hasNext(YEAR)) {
s.next(YEAR);
MatchResult mr = s.match();
if (mr.group(1) != null) {
return 1900; // systemv has min
} else if (mr.group(2) != null) {
return YEAR_MAX_VALUE;
} else if (mr.group(3) != null) {
return defaultYear;
}
return Integer.parseInt(mr.group(4));
/*
if (mr.group("min") != null) {
//return YEAR_MIN_VALUE;
return 1900; // systemv has min
} else if (mr.group("max") != null) {
return YEAR_MAX_VALUE;
} else if (mr.group("only") != null) {
return defaultYear;
}
return Integer.parseInt(mr.group("year"));
*/
}
throw new IllegalArgumentException("Unknown year: " + s.next());
}
/**
* 21.2.5.2.1 Runtime Semantics: RegExpExec ( R, S ) (1)
*
* @param cx
* the execution context
* @param r
* the regular expression object
* @param s
* the string
* @param storeResult
* {@code true} if the match result is stored
* @return the match result object or null
*/
private static MatchResult matchResultOrNull(ExecutionContext cx, ScriptObject r, String s, boolean storeResult) {
/* steps 1-2 (not applicable) */
/* step 3 */
Object exec = Get(cx, r, "exec");
/* step 4 */
// Don't take the slow path for built-in RegExp.prototype.exec
if (IsCallable(exec) && !isBuiltinExec(cx.getRealm(), exec)) {
ScriptObject o = RegExpUserExec(cx, (Callable) exec, r, s);
return o != null ? new ScriptObjectMatchResult(cx, o) : null;
}
/* step 5 */
RegExpObject rx = thisRegExpObject(cx, r, "RegExp.prototype.exec");
/* step 6 */
return matchResultOrNull(cx, rx, s, storeResult);
}
private int getTruePositiveTokenCount( Mutant mutant){
int count = 0;
Pattern mask = Pattern.compile("X+");
List<MatchResult> results = new ArrayList<>();
Matcher matcher = mask.matcher(mutant.getDeidentifiedString());
while (matcher.find()){
results.add(matcher.toMatchResult());
}
for(MatchResult result: results) {
StringTokenizer tokenizer = new StringTokenizer(mutant.getFinalText().substring(result.start(),result.end()));
ArrayList<String> arHits = new ArrayList<>();
while (tokenizer.hasMoreTokens()){
arHits.add(tokenizer.nextToken());
}
count = getHitCount(mutant, count, arHits);
}
return count;
}
/**
* Find all prefixes declared in the query
* @param queryString
* @return
*/
protected static Set<String> findQueryPrefixes(String queryString) {
Set<String> res = new HashSet<String>();
Scanner sc = new Scanner(queryString);
while (true) {
while (sc.findInLine(prefixPattern)!=null) {
MatchResult m = sc.match();
res.add(m.group(1));
}
if (!sc.hasNextLine())
break;
sc.nextLine();
}
sc.close();
return res;
}
/** Replaces the given match with the given replacement string. */
void replace(MatchResult match, String replacement) {
Preconditions.checkArgument(
match.group().equals(value.substring(match.start(), match.end())),
"MatchResult does not match the current value of this string");
value = value.substring(0, match.start()) + replacement + value.substring(match.end());
}
private Either<Throwable, Expression> createAssignmentWithType(String expression) {
try {
MatchResult match = Patterns.assignmentWithTypeNamePattern.match(expression);
java.lang.reflect.Method declaredMethod = detectMethod(match.group(1) + " " + randomIdentifier("method") + "(){}");
return right((Expression) new AssignmentWithType(expression, declaredMethod.getGenericReturnType(), match.group(2), match.group(3)));
} catch (Exception e) {
return left(Utils.unwrapException(e));
}
}
private MatchResult getMatchResult(Matcher matcher, boolean onlyFirst) {
MatchResult matchResult = null;
while (matcher.find()) {
matchResult = matcher.toMatchResult();
if (onlyFirst) {
break;
}
}
return matchResult;
}
@Override
protected String group(int index, int groupNumber) {
MatchResult result = getMatch(index);
if (0 <= groupNumber && groupNumber <= result.groupCount()) {
return result.group(groupNumber);
}
return null;
}
public MatchResult parse(final ParserInput parserInput) throws ParserFailure {
final Matcher matcher = pattern.matcher(
parserInput.getText().subSequence(parserInput.getOffset(),
parserInput.getText().length())
);
if (matcher.lookingAt()) {
parserInput.setOffset(parserInput.getOffset() + matcher.end());
return matcher.toMatchResult();
}
else {
throw new ParserFailure("Regular Expression parser with pattern '" + pattern.pattern()
+ "' did not match the input text ( using matcher.lookingAt() )", parserInput);
}
}
public static float getCPUBogoMips() throws SystemUtilsException {
final MatchResult matchResult = SystemUtils.matchSystemFile("/proc/cpuinfo", SystemUtils.BOGOMIPS_PATTERN, 1000);
try {
if (matchResult.groupCount() > 0) {
return Float.parseFloat(matchResult.group(1));
} else {
throw new SystemUtilsException();
}
} catch (final NumberFormatException e) {
throw new SystemUtilsException(e);
}
}