private String getTailFromName(String currentName) { Matcher m = fileNameRE.matcher(currentName); m.matches(); String tail = ""; int groupCount = m.groupCount(); if (prepend) { tail += '\n'; } else { if (groupCount > 0) { tail += separator; } } for (int i = 1; i <= groupCount; i++) { tail += m.group(i); if (i < groupCount) { tail += separator; } } if (prepend) { if (groupCount > 0) { tail += separator; } } else { tail += '\n'; } return tail; }
/** Modifies events in-place. */ public Event intercept(Event event) { Map<String, String> headers = event.getHeaders(); String msg = new String(event.getBody(), charset); logger.debug(String.format("MsmRegexExtractInterceptor original body=%s", msg)); Matcher matcher = this.pattern.matcher(msg); final List<String> tagValues = new ArrayList<String>(); while (matcher.find() && matcher.groupCount() > 0) { tagValues.add(matcher.group(1)); } if (tagValues.size() > 0) { msg = StringUtils.join(tagValues, "\n"); } logger.debug(String.format("MsmRegexExtractInterceptor extract body=%s", msg)); event.setBody(msg.getBytes()); // set header based on the message type (for demonstration purpose) Matcher typeMatcher = Pattern.compile("<repd:IdPRM>([0-9]+)</repd:IdPRM>", Pattern.DOTALL | Pattern.MULTILINE) .matcher(msg); String messageType = (typeMatcher.find() && typeMatcher.groupCount() > 0) ? ((Integer.parseInt(typeMatcher.group(1))) % 2 == 0 ? "TypeA" : "TypeB") : "unknown"; logger.debug(String.format("MsmRegexExtractInterceptor type-id=%s", messageType)); headers.put("type-id", messageType); return event; }
private void route(HttpServerRequest request, List<PatternBinding> bindings) { for (PatternBinding binding : bindings) { Matcher m = binding.pattern.matcher(request.path); if (m.matches()) { Map<String, String> params = new HashMap<>(m.groupCount()); if (binding.paramNames != null) { // Named params for (String param : binding.paramNames) { params.put(param, m.group(param)); } } else { // Un-named params for (int i = 0; i < m.groupCount(); i++) { params.put("param" + i, m.group(i + 1)); } } request.getParams().putAll(params); binding.handler.handle(request); return; } } // If we get here it wasn't routed request.response.statusCode = 404; request.response.end(); }
/** * (1)能匹配的年月日类型有: 2014年4月19日 2014年4月19号 2014-4-19 2014/4/19 2014.4.19 (2)能匹配的时分秒类型有: 15:28:21 * 15:28 5:28 pm 15点28分21秒 15点28分 15点 (3)能匹配的年月日时分秒类型有: (1)和(2)的任意组合,二者中间可有任意多个空格 * 如果dateStr中有多个时间串存在,只会匹配第一个串,其他的串忽略 * * @param text * @return */ @SuppressWarnings("unchecked") private static String matchDateString(String dateStr) { try { List<String> matches = null; Pattern p = Pattern.compile( "(\\d{1,4}[-|\\/|年|\\.]\\d{1,2}[-|\\/|月|\\.]\\d{1,2}([日|号])?(\\s)*(\\d{1,2}([点|时])?((:)?\\d{1,2}(分)?((:)?\\d{1,2}(秒)?)?)?)?(\\s)*(PM|AM)?)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE); Matcher matcher = p.matcher(dateStr); if (matcher.find() && matcher.groupCount() >= 1) { matches = new ArrayList<String>(); for (int i = 1; i <= matcher.groupCount(); i++) { String temp = matcher.group(i); matches.add(temp); } } else { matches = Collections.EMPTY_LIST; } if (matches.size() > 0) { return ((String) matches.get(0)).trim(); } else { } } catch (Exception e) { return ""; } return dateStr; }
public Properties getViewData(String viewTag) throws IOException, InterruptedException { Properties resPrp = new Properties(); ArgumentListBuilder cmd = new ArgumentListBuilder(); cmd.add("lsview"); cmd.add("-l", viewTag); Pattern uuidPattern = Pattern.compile("View uuid: (.*)"); Pattern globalPathPattern = Pattern.compile("View server access path: (.*)"); boolean res = true; IOException exception = null; List<IOException> exceptions = new ArrayList<IOException>(); String output = runAndProcessOutput(cmd, null, null, true, exceptions); // handle the use case in which view doesn't exist and therefore error is thrown if (!exceptions.isEmpty() && !output.contains("No matching entries found for view")) { throw exceptions.get(0); } if (res && exception == null) { String[] lines = output.split("\n"); for (String line : lines) { Matcher matcher = uuidPattern.matcher(line); if (matcher.find() && matcher.groupCount() == 1) resPrp.put("UUID", matcher.group(1)); matcher = globalPathPattern.matcher(line); if (matcher.find() && matcher.groupCount() == 1) resPrp.put("STORAGE_DIR", matcher.group(1)); } } return resPrp; }
public static String formatKernelVersion(String rawKernelVersion) { // Example (see tests for more): // Linux version 3.0.31-g6fb96c9 ([email protected]) \ // (gcc version 4.6.x-xxx 20120106 (prerelease) (GCC) ) #1 SMP PREEMPT \ // Thu Jun 28 11:02:39 PDT 2012 final String PROC_VERSION_REGEX = "Linux version (\\S+) " + /* group 1: "3.0.31-g6fb96c9" */ "\\((\\S+?)\\) " + /* group 2: "*****@*****.**" (kernel builder) */ "(?:\\(gcc.+? \\)) " + /* ignore: GCC version information */ "(#\\d+) " + /* group 3: "#1" */ "(?:.*?)?" + /* ignore: optional SMP, PREEMPT, and any CONFIG_FLAGS */ "((Sun|Mon|Tue|Wed|Thu|Fri|Sat).+)"; /* group 4: "Thu Jun 28 11:02:39 PDT 2012" */ Matcher m = Pattern.compile(PROC_VERSION_REGEX).matcher(rawKernelVersion); if (!m.matches()) { Log.e(LOG_TAG, "Regex did not match on /proc/version: " + rawKernelVersion); return "Unavailable"; } else if (m.groupCount() < 4) { Log.e(LOG_TAG, "Regex match on /proc/version only returned " + m.groupCount() + " groups"); return "Unavailable"; } return m.group(1) + "\n" + // 3.0.31-g6fb96c9 m.group(2) + " " + m.group(3) + "\n" + // [email protected] #1 m.group(4); // Thu Jun 28 11:02:39 PDT 2012 }
/** * Creates a new {@code UriPathTemplate} from the given {@code uriPattern}. * * @param uriPattern The pattern to be used by the template */ public UriPathTemplate(String uriPattern) { String s = "^" + uriPattern; Matcher m = NAME_SPLAT_PATTERN.matcher(s); while (m.find()) { for (int i = 1; i <= m.groupCount(); i++) { String name = m.group(i); pathVariables.add(name); s = m.replaceFirst(NAME_SPLAT_REPLACEMENT.replaceAll("%NAME%", name)); m.reset(s); } } m = NAME_PATTERN.matcher(s); while (m.find()) { for (int i = 1; i <= m.groupCount(); i++) { String name = m.group(i); pathVariables.add(name); s = m.replaceFirst(NAME_REPLACEMENT.replaceAll("%NAME%", name)); m.reset(s); } } m = FULL_SPLAT_PATTERN.matcher(s); while (m.find()) { s = m.replaceAll(FULL_SPLAT_REPLACEMENT); m.reset(s); } this.uriPattern = Pattern.compile(s + "$"); }
/** * Clear the results and display notice to say an error occurred. * * @param error the error that occurred. */ public void displayErrorResult(final Throwable error) { // match some friendly error messages. String errorText = null; if (error.getCause() != null && error.getCause() instanceof CheckstyleException) { for (final Pattern errorPattern : CHECKSTYLE_ERROR_PATTERNS.keySet()) { final Matcher errorMatcher = errorPattern.matcher(error.getCause().getMessage()); if (errorMatcher.find()) { final Object[] args = new Object[errorMatcher.groupCount()]; for (int i = 0; i < errorMatcher.groupCount(); ++i) { args[i] = errorMatcher.group(i + 1); } errorText = CheckStyleBundle.message(CHECKSTYLE_ERROR_PATTERNS.get(errorPattern), args); } } } if (errorText == null) { errorText = CheckStyleBundle.message("plugin.results.error"); } treeModel.clear(); treeModel.setRootText(errorText); clearProgress(); }
// From: line processing public static int detectFeature7(String[] tmp) { int result = 0; if (fromLine == 0) return result; // nothing can be done // String inputStr = "abbabcd"; String inputStr = arrayOfLines[fromLine]; // String patternStr = "(a(?:b*))+(c*)"; String patternStr = "([A-Z][a-z]+\\s\\s?[A-Z]?[\\.]?\\s\\s?([A-Z][a-z]+))"; // Compile and use regular expression Pattern mypattern = Pattern.compile(patternStr); Matcher matcher = mypattern.matcher(inputStr); boolean matchFound = matcher.find(); if (matchFound) { int groupsize = matcher.groupCount() + 1; String[] groupStr = new String[groupsize]; for (int j = 0; j <= matcher.groupCount(); j++) { groupStr[j] = matcher.group(j); // System.out.println("groupSTR = " + groupStr[j]); for (int i = lastSearchLine; i >= firstSearchLine; i--) { if (myMatcher(groupStr[j], tmp[i])) { log.debug(tmp[i]); return i; } } } } else { // another string pattern patternStr = "([A-Z][a-z]+\\s\\s?([A-Z][a-z]+))"; // Compile and use regular expression Pattern myPattern = Pattern.compile(patternStr); Matcher myMatcher = myPattern.matcher(inputStr); matchFound = myMatcher.find(); if (matchFound) { int groupsize = matcher.groupCount() + 1; String[] groupStr = new String[groupsize]; for (int j = 0; j <= myMatcher.groupCount(); j++) { groupStr[j] = myMatcher.group(j); // System.out.println("groupSTR = " + groupStr[j]); for (int i = lastSearchLine; i >= firstSearchLine; i--) { if (myMatcher(groupStr[j], tmp[i])) { log.debug(tmp[i]); return i; } } } } } return result; }
public static AnyRequest parse(final String originalTarget) throws MalformedRequestException { final Matcher matcher = DOCUMENT_PATTERN.matcher(originalTarget); if (matcher.find() && matcher.groupCount() >= 4) { // Document source name plus extension, minus page identifier. final String fullTarget = matcher.group(2) + "." + matcher.group(4); final boolean showProblems = fullTarget.endsWith(ERRORPAGE_SUFFIX); final String targetMinusError; if (showProblems) { targetMinusError = fullTarget.substring(0, fullTarget.length() - ERRORPAGE_SUFFIX.length()); } else { targetMinusError = fullTarget; } final String rawDocumentMimeType = extractExtension(targetMinusError); final String rawDocumentSourceName = targetMinusError.substring( 0, targetMinusError.length() - rawDocumentMimeType.length() - 1); final String maybePageIdentifier = matcher.group(3); final PageIdentifier pageIdentifier = maybePageIdentifier == null ? null : new PageIdentifier(maybePageIdentifier); final RenditionMimeType renditionMimeType = RenditionMimeType.maybeValueOf( rawDocumentMimeType == null ? null : rawDocumentMimeType.toUpperCase()); final ImmutableMap<String, String> parameterMap = matcher.groupCount() >= 5 ? getQueryMap(matcher.group(5)) : ImmutableMap.<String, String>of(); verifyAllParameterNames(parameterMap.keySet()); final ResourceName alternateStylesheet = extractResourceName(parameterMap); final ImmutableSet<Tag> tagset = extractTags(parameterMap); final AnyRequest request; if (renditionMimeType == null) { request = new GenericRequest(originalTarget, rawDocumentSourceName, rawDocumentMimeType); } else { request = new GenericRequest( originalTarget, rawDocumentSourceName, showProblems, renditionMimeType, pageIdentifier, alternateStylesheet, tagset); } return request; } else { throw new MalformedRequestException("Could not parse: '" + originalTarget + "'."); } }
Object invokeMethod(Object objectToInvoke) { Method method = getNaturalLanguageMethod().getMethod(); List<ArgumentConverter> argumentConverters = naturalLanguageMethod.getArgumentConverters(); Object[] args = new Object[matcher.groupCount()]; for (int i = 0; i < matcher.groupCount(); i++) { String group = matcher.group(i + 1); args[i] = argumentConverters.get(i).convertArgument(group, naturalLanguageMethod, i); } return ReflectionUtil.invokeWithArgs(method, objectToInvoke, args); }
private static String checkAttributes(final String tag, StringBuilder errorMessages) { if (M_goodAttributes == null) init(); Matcher fullTag = M_patternTagPieces.matcher(tag); String close = ""; StringBuilder buf = new StringBuilder(); String leftOvers = ""; if (fullTag.matches() && fullTag.groupCount() > 2) { leftOvers = fullTag.group(2); buf.append(fullTag.group(1)); close = fullTag.group(fullTag.groupCount()); } else { if (M_log.isDebugEnabled()) M_log.debug("Could not parse " + tag); return ""; } String tagName = tag; if (tag != null && tag.length() > 2) { int pos = tag.indexOf(' '); if (pos <= 0) { pos = tag.indexOf('/'); } if (pos <= 0) { pos = tag.indexOf('>'); } if (pos > 0) { tagName = tag.substring(1, pos); } } Matcher matcher; for (int i = 0; i < M_goodAttributePatterns.length; i++) { matcher = M_goodAttributePatterns[i].matcher(tag); if (matcher.find()) { for (int j = 0; j < matcher.groupCount(); j++) { if (checkValue(tagName, matcher.group(j) + " ", errorMessages)) { buf.append(matcher.group(j) + " "); try { leftOvers = leftOvers.replace(matcher.group(j), ""); } catch (Exception e) { M_log.warn(matcher.group(j)); e.printStackTrace(); } } } } } if (leftOvers != null && leftOvers.trim().length() > 1) { errorMessages.append("The HTML attribute pattern '" + leftOvers + "' is not allowed\n"); } buf.append(close); return buf.toString(); }
public static String[] regGroup(String text, String reg) { Matcher m = Pattern.compile(reg, Pattern.CASE_INSENSITIVE).matcher(text); if (!m.find()) { return null; } String[] res = new String[m.groupCount() + 1]; for (int i = 0; i <= m.groupCount(); i++) { res[i] = m.group(i).trim(); } return res; }
/** Extracts document location from a Zope-like URL ie : server/path_or_docId/view_id/tab_id . */ @Override public DocumentView getDocumentViewFromUrl(String url) { final Pattern pattern = Pattern.compile(getPrefix() + URLPattern); Matcher m = pattern.matcher(url); if (m.matches()) { if (m.groupCount() >= 4) { // for debug // for (int i = 1; i < m.groupCount() + 1; i++) { // System.err.println(i + ": " + m.group(i)); // } final String server = m.group(1); String uuid = m.group(2); final DocumentRef docRef = new IdRef(uuid); // get other parameters Map<String, String> params = new HashMap<String, String>(); if (m.groupCount() >= 4) { String filePropertyPath = m.group(4); params.put(FILE_PROPERTY_PATH_KEY, filePropertyPath); } if (m.groupCount() >= 6) { String filename = m.group(6); try { filename = URLDecoder.decode(filename, "UTF-8"); } catch (UnsupportedEncodingException e) { filename = StringUtils.toAscii(filename); } int jsessionidIndex = filename.indexOf(";jsessionid"); if (jsessionidIndex != -1) { filename = filename.substring(0, jsessionidIndex); } params.put(FILENAME_KEY, filename); } if (m.groupCount() >= 8) { String query = m.group(8); Map<String, String> requestParams = URIUtils.getRequestParameters(query); if (requestParams != null) { params.putAll(requestParams); } } final DocumentLocation docLoc = new DocumentLocationImpl(server, docRef); return new DocumentViewImpl(docLoc, null, params); } } return null; }
public static List<String[]> regGroupAll(String text, String reg) { List<String[]> ans = new ArrayList<String[]>(); Matcher m = Pattern.compile(reg, Pattern.CASE_INSENSITIVE).matcher(text); while (m.find()) { String[] res = new String[m.groupCount() + 1]; for (int i = 0; i <= m.groupCount(); i++) { res[i] = m.group(i).trim(); } ans.add(res); } return ans; }
protected List<String> getFinderComponents(String finderName) { Matcher matcher = validFinderPattern.matcher(finderName); if (!matcher.matches()) { return null; } else { List<String> matches = new ArrayList<String>(matcher.groupCount()); for (int i = 1; i <= matcher.groupCount(); i++) { matches.add(matcher.group(i)); } return matches; } }
public ControllerRequest(Class<? extends Controller> controllerClass, Matcher matchedUrl) { this.controllerClass = controllerClass; if (matchedUrl.groupCount() > 0) { List<String> argsList = new ArrayList<String>(matchedUrl.groupCount()); for (int i = 1; i <= matchedUrl.groupCount(); i++) { argsList.add(matchedUrl.group(i)); } this.args = argsList; } else { this.args = new ArrayList<String>(0); } }
public static String[] regexGroup(String regex, String str) { Pattern p = Pattern.compile(regex, Pattern.MULTILINE); // ""); Matcher m = p.matcher(str); if (m.find()) { String[] result = new String[m.groupCount() + 1]; for (int i = 0; i <= m.groupCount(); i++) { result[i] = m.group(i); } return result; } return null; }
/** * Try to parse a prefix of current string by given pattern. If succeed current string will be * replaced by remaining suffix. Else will return null and current string will not change. * * @param pattern * @return array of matcher groups if pattern successfully matches prefix of current string, * otherwise - null. First element of returned array (index - 0) contains whole string matched * by given pattern. */ public String[] consumeOptional(Pattern pattern) { Matcher m = pattern.matcher(currentString); if (m.lookingAt()) { String[] result = new String[m.groupCount() + 1]; result[0] = m.group(); for (int i = 1; i <= m.groupCount(); i++) { result[i] = m.group(i); } currentString = currentString.substring(m.end()); return result; } else { return null; } }
Request(String str) throws ParseException { Matcher matcher = requestPattern.matcher(str); if (!matcher.matches()) { throw new ParseException("No matches found when parsing request: " + str, 0); } if (3 != matcher.groupCount()) { throw new ParseException( "Error parsing request: " + str + " ; groupCount = " + matcher.groupCount(), 0); } this.method = matcher.group(1); this.url = matcher.group(2); this.protocol = matcher.group(3); }
/** Tests {@link PatternConsts#LANG_AND_COUNTRY} regular expression. */ public void testLangAndCountry() { String LC_BAD = "abc*DEF"; Matcher m = PatternConsts.LANG_AND_COUNTRY.matcher(LC_BAD); if (m.matches()) fail( "Language and Country pattern '" + PatternConsts.LANG_AND_COUNTRY.pattern() + "' incorrectly matches a wrong string '" + LC_BAD + "'"); String LC_GOOD = "abc-DEF"; m = PatternConsts.LANG_AND_COUNTRY.matcher(LC_GOOD); if (!m.matches()) fail( "Language and Country pattern '" + PatternConsts.LANG_AND_COUNTRY.pattern() + "' does not match a good string '" + LC_GOOD + "'"); if (m.groupCount() != 2) fail("Wrong group count extracted (" + m.groupCount() + "), should be 2."); if (!m.group(1).equals("abc")) fail("Wrong language extracted"); if (!m.group(2).equals("DEF")) fail("Wrong country extracted"); String L_GOOD = "abc"; m = PatternConsts.LANG_AND_COUNTRY.matcher(L_GOOD); if (!m.matches()) fail( "Language and Country pattern '" + PatternConsts.LANG_AND_COUNTRY.pattern() + "' does not match a good string '" + L_GOOD + "'"); if (!m.group(1).equals("abc")) fail("Wrong language extracted"); if (m.group(2) != null) fail("Country extracted, but it should not"); String C_GOOD = "Z-abc"; m = PatternConsts.LANG_AND_COUNTRY.matcher(C_GOOD); if (!m.matches()) fail( "Language and Country pattern '" + PatternConsts.LANG_AND_COUNTRY.pattern() + "' does not match a good string '" + C_GOOD + "'"); if (!m.group(1).equals("Z")) fail("Wrong language extracted"); if (!m.group(2).equals("abc")) fail("Wrong country extracted"); }
public Date getDateFromName(Path target, boolean fillEmptyDateSection) { String name = target.getFileName().toString(); String year = null, month = null, day = null; Pattern pattern = Pattern.compile( getRegexp(mask.replaceAll(FULL_YEAR_PATTERN, "([0-9]{4})")), Pattern.CASE_INSENSITIVE); Matcher matcher = pattern.matcher(name); if (matcher.find() && matcher.groupCount() > 0) { year = matcher.group(1).substring(2); } pattern = Pattern.compile( getRegexp(mask.replaceAll(SHORT_YEAR_PATTERN, "([0-9]{2})")), Pattern.CASE_INSENSITIVE); matcher = pattern.matcher(name); if (matcher.find() && matcher.groupCount() > 0) { year = matcher.group(1); } pattern = Pattern.compile( getRegexp(mask.replaceAll(MONTH_PATTERN, "([0-9]{2})")), Pattern.CASE_INSENSITIVE); matcher = pattern.matcher(name); if (matcher.find() && matcher.groupCount() > 0) { month = matcher.group(1); } pattern = Pattern.compile( getRegexp(mask.replaceAll(DAY_PATTERN, "([0-9]{2})")), Pattern.CASE_INSENSITIVE); matcher = pattern.matcher(name); if (matcher.find() && matcher.groupCount() > 0) { day = matcher.group(1); } if (fillEmptyDateSection) { year = year == null ? "70" : year; month = month == null ? "01" : month; day = day == null ? "01" : day; } else if (year == null || month == null || day == null) { return null; } try { String stringDate = String.format("%s%s%s", year, month, day); return new SimpleDateFormat(SHORT_DATE_PATTERN).parse(stringDate); } catch (ParseException ex) { LOGGER.error("Parse date exception", ex); return null; } }
public static int calculateVersion(String version) { if (null == version) { return UNKNOWN_HAZELCAST_VERSION; } Matcher matcher = VERSION_PATTERN.matcher(version); if (matcher.matches()) { try { int calculatedVersion = MAJOR_VERSION_MULTIPLIER * Integer.parseInt(matcher.group(1)) + MINOR_VERSION_MULTIPLIER * Integer.parseInt(matcher.group(2)); int groupCount = matcher.groupCount(); if (groupCount >= PATCH_GROUP_COUNT) { String patchVersionString = matcher.group(PATCH_GROUP_COUNT); if (null != patchVersionString && !patchVersionString.startsWith("-")) { calculatedVersion += Integer.parseInt(patchVersionString); } } return calculatedVersion; } catch (Exception e) { Logger.getLogger(BuildInfo.class) .warning("Failed to calculate version using version string " + version, e); } } return UNKNOWN_HAZELCAST_VERSION; }
/** * Match a URI against the pattern. * * <p>If the URI matches against the pattern then the capturing group values (if any) will be * added to a list passed in as parameter. * * @param uri the uri to match against the template. * @param groupValues the list to add the values of a pattern's capturing groups if matching is * successful. The values are added in the same order as the pattern's capturing groups. The * list is cleared before values are added. * @return true if the URI matches the pattern, otherwise false. * @throws IllegalArgumentException if the uri or capturingGroupValues is null. */ public final boolean match(CharSequence uri, List<String> groupValues) { if (groupValues == null) throw new IllegalArgumentException(); // Check for match against the empty pattern if (uri == null || uri.length() == 0) return (regexPattern == null) ? true : false; else if (regexPattern == null) return false; // Match the URI to the URI template regular expression Matcher m = regexPattern.matcher(uri); if (!m.matches()) return false; groupValues.clear(); if (groupIndexes.length > 0) { for (int i = 0; i < groupIndexes.length - 1; i++) { groupValues.add(m.group(groupIndexes[i])); } } else { for (int i = 1; i <= m.groupCount(); i++) { groupValues.add(m.group(i)); } } // TODO check for consistency of different capturing groups // that must have the same value return true; }
/** * Return info about this regex. Does it match the text, how many groups, etc. * * @param text body of text * @param regex regex expression to run against the text * @param flags Pattern.DOTALL, MULTILINE, CASE_INSENSITIVE, etc. * @return text about matches */ public static String getRegexInfo(String text, String regex, int flags) { try { if (text.isEmpty() || regex.isEmpty()) { return ""; } Pattern pat = Pattern.compile(regex, flags); Matcher mat = pat.matcher(text); int matchCount = 0; StringBuilder builder = new StringBuilder(); while (mat.find()) { matchCount++; builder.append(String.format(" Match: \"%s\"\n", mat.group(0))); // Weirdness alert: groupCount() doesn't include group(0), which is the full match. // Thus if groupCount() == 1, we want to display group(1), not group(0). for (int gCount = 1; gCount <= mat.groupCount(); gCount++) { builder.append(String.format(" Group %d: \"%s\"\n", gCount, mat.group(gCount))); } builder.append("\n"); } return String.format("Matches: %d\n%s", matchCount, builder.toString()); } catch (Exception e) { return ""; } }
/** * Obtains the version numbers of CraftBukkit, Minecraft, and Minequery. * * @return A <code>Map</code> of versions. */ private static Map<String, String> getVersions() { Map<String, String> versions = new HashMap<String, String>(); // Find the CraftBukkit build and the Minecraft version. String version = minequery.getServer().getVersion(); Matcher matcher = Pattern.compile("git-Bukkit-.*-b(\\d+)jnks \\(MC: (.*)\\)").matcher(version); List<Object> matchList = new ArrayList<Object>(); while (matcher.find()) { for (int i = 1; i <= matcher.groupCount(); i++) { matchList.add(matcher.group(i)); } } // One day the version string could completely change, // so check if we have at last two matches. if (matchList.size() > 1) { versions.put("craftbukkit", matchList.get(0).toString()); versions.put("minecraft", matchList.get(1).toString()); } // Add the Minequery version. versions.put("minequery", minequery.getDescription().getVersion()); return versions; }
/** * @param string * @param pattern * @param flags * @return * @throws XPathException */ private Sequence match(String string, String pattern, int flags) throws XPathException { try { Matcher matcher; if (cachedRegexp == null || (!cachedRegexp.equals(pattern)) || flags != cachedPattern.flags()) { matcher = Pattern.compile(pattern, flags).matcher(string); cachedPattern = matcher.pattern(); cachedRegexp = string; } else { matcher = cachedPattern.matcher(string); } if (!matcher.find()) { return Sequence.EMPTY_SEQUENCE; } else { int items = matcher.groupCount() + 1; Sequence seq = new ValueSequence(); seq.add(new StringValue(string)); for (int i = 1; i < items; i++) { String val = matcher.group(i); if (val == null) { val = ""; } seq.add(new StringValue(val)); } return seq; } } catch (PatternSyntaxException e) { throw new XPathException("Invalid regular expression: " + e.getMessage(), e); } }
/** Parse PID line from 'qstat' (Cmd) */ public String parsePidLine(String line) { if (pidPattern == null || line.isEmpty()) return ""; // Pattern pattern = Pattern.compile("Your job (\\S+)"); Matcher matcher = pidPattern.matcher(line); if (matcher.find()) { String pid = null; if (matcher.groupCount() > 0) pid = matcher.group(1); // Use first group else pid = matcher.group(0); // Use whole pattern if (debug) log( "Regex '" + pidPatternStr + "' (" + Config.PID_CHECK_TASK_RUNNING_REGEX + ") matched '" + pid + "' in line: '" + line + "'"); return pid; } else if (debug) log( "Regex '" + pidPatternStr + "' (" + Config.PID_CHECK_TASK_RUNNING_REGEX + ") did NOT match line: '" + line + "'"); return line; }
public static void main(String[] args) throws PatternSyntaxException { Scanner in = new Scanner(System.in); System.out.println("Enter pattern: "); String patternString = in.nextLine(); Pattern pattern = Pattern.compile(patternString); while (true) { System.out.println("Enter string to match: "); String input = in.nextLine(); if (input == null || input.equals("")) return; Matcher matcher = pattern.matcher(input); if (matcher.matches()) { System.out.println("Match"); int g = matcher.groupCount(); if (g > 0) { for (int i = 0; i < input.length(); i++) { // Print any empty groups for (int j = 1; j <= g; j++) if (i == matcher.start(j) && i == matcher.end(j)) System.out.print("()"); // Print ( for non-empty groups starting here for (int j = 1; j <= g; j++) if (i == matcher.start(j) && i != matcher.end(j)) System.out.print('('); System.out.print(input.charAt(i)); // Print ) for non-empty groups ending here for (int j = 1; j <= g; j++) if (i + 1 != matcher.start(j) && i + 1 == matcher.end(j)) System.out.print(')'); } System.out.println(); } } else System.out.println("No match"); } }
/** * 检验是否有效的邮件地址 * * @param addr * @return */ public static boolean isValidEmailAddress(String addr) { if (addr == null) return false; addr = addr.trim(); if (addr.length() == 0) return false; Matcher matcher = basicAddressPattern.matcher(addr); if (!matcher.matches()) return false; String userPart = matcher.group(1); String domainPart = matcher.group(2); matcher = validUserPattern.matcher(userPart); if (!matcher.matches()) return false; matcher = ipDomainPattern.matcher(domainPart); if (matcher.matches()) { for (int i = 1; i < 5; i++) { String num = matcher.group(i); if (num == null) return false; if (Integer.parseInt(num) > 254) return false; } return true; } matcher = domainPattern.matcher(domainPart); if (matcher.matches()) { String tld = matcher.group(matcher.groupCount()); matcher = tldPattern.matcher(tld); return tld.length() == 3 || matcher.matches(); } else { return false; } }