How to use

compile

method

in

java.util.regex.Pattern

 String mydata = "some string with 'the data i want' inside";
Pattern pattern = Pattern.compile("'(.*?)'");
Matcher matcher = pattern.matcher(mydata);
if (matcher.find())
{
  System.out.println(matcher.group(1));
}

/**
 * See {@link hudson.FilePath#isAbsolute(String)}.
 * @param path String representing <code> Platform Specific </code> (unlike FilePath, which may get Platform agnostic paths), may not be null
 * @return true if String represents absolute path on this platform, false otherwise
 */
public static boolean isAbsolute(String path) {
  Pattern DRIVE_PATTERN = Pattern.compile("[A-Za-z]:[\\\\/].*");
  return path.startsWith("/") || DRIVE_PATTERN.matcher(path).matches();
}

public boolean matches(String actual) {
  return actual != null && Pattern.compile(regex).matcher(actual).find();
}

 for (MatchResult match : allMatches(Pattern.compile("[abc]"), "abracadabra")) {
 System.out.println(match.group() + " at " + match.start());
}

private String getError (String line) {
  Pattern pattern = Pattern.compile(":[0-9]+:[0-9]+:(.+)");
  Matcher matcher = pattern.matcher(line);
  matcher.find();
  return matcher.groupCount() >= 1 ? matcher.group(1).trim() : null;
}

/**
 * Given a String the method uses Regex to check if the String only contains punctuation characters
 *
 * @param s a String to check using regex
 * @return true if the String is valid
 */
public static boolean isPunct(String s){
 Pattern p = Pattern.compile("^[\\p{Punct}]+$");
 Matcher m = p.matcher(s);
 return m.matches();
}

/**
 * Returns a new {@code MatchResult} that corresponds to a successful match. Apache Harmony (used
 * in Android) requires a successful match in order to generate a {@code MatchResult}:
 * http://goo.gl/5VQFmC
 */
private static MatchResult newMatchResult() {
 Matcher matcher = Pattern.compile(".").matcher("X");
 matcher.find();
 return matcher.toMatchResult();
}

 Pattern p = Pattern.compile("^[a-zA-Z]+([0-9]+).*");
Matcher m = p.matcher("Testing123Testing");

if (m.find()) {
  System.out.println(m.group(1));
}

/**
 * Given a String the method uses Regex to check if the String only contains alphanumeric characters
 *
 * @param s a String to check using regex
 * @return true if the String is valid
 */
public static boolean isAlphanumeric(String s){
 Pattern p = Pattern.compile("^[\\p{Alnum}\\s\\.]+$");
 Matcher m = p.matcher(s);
 return m.matches();
}

/** 判断是否Flyme4以上 */
public static boolean isFlyme4Later() {
  return Build.FINGERPRINT.contains("Flyme_OS_4")
      || Build.VERSION.INCREMENTAL.contains("Flyme_OS_4")
      || Pattern.compile("Flyme OS [4|5]", Pattern.CASE_INSENSITIVE).matcher(Build.DISPLAY).find();
}

private String getError (String line) {
  Pattern pattern = Pattern.compile(":[0-9]+:[0-9]+:(.+)");
  Matcher matcher = pattern.matcher(line);
  matcher.find();
  return matcher.groupCount() >= 1 ? matcher.group(1).trim() : null;
}

/**
 * Given a String the method uses Regex to check if the String only contains alphabet characters
 *
 * @param s a String to check using regex
 * @return true if the String is valid
 */
public static boolean isAlpha(String s){
 Pattern p = Pattern.compile("^[\\p{Alpha}\\s]+$");
 Matcher m = p.matcher(s);
 return m.matches();
}

 private static void assertContainsRegex(String expectedRegex, String actual) {
  Pattern pattern = Pattern.compile(expectedRegex);
  Matcher matcher = pattern.matcher(actual);
  if (!matcher.find()) {
   String actualDesc = (actual == null) ? "null" : ('<' + actual + '>');
   fail("expected to contain regex:<" + expectedRegex + "> but was:" + actualDesc);
  }
 }
}

  private int getLineNumber (String line) {
    Pattern pattern = Pattern.compile(":([0-9]+):[0-9]+:");
    Matcher matcher = pattern.matcher(line);
    matcher.find();
    return matcher.groupCount() >= 1 ? Integer.parseInt(matcher.group(1)) : -1;
  }
});

public static boolean isWhitespaceOrPunct(String c) {
 Pattern punctOrWhite = Pattern.compile("[\\s\\p{Punct}]", Pattern.UNICODE_CHARACTER_CLASS);
 Matcher m = punctOrWhite.matcher(c);
 return m.matches();
}

private void assertTableProperty(String tableProperties, String key, String regexValue)
{
  assertTrue(Pattern.compile(key + "\\s*=\\s*" + regexValue + ",?\\s+").matcher(tableProperties).find(),
      "Not found: " + key + " = " + regexValue + " in " + tableProperties);
}

  private int getLineNumber (String line) {
    Pattern pattern = Pattern.compile(":([0-9]+):[0-9]+:");
    Matcher matcher = pattern.matcher(line);
    matcher.find();
    return matcher.groupCount() >= 1 ? Integer.parseInt(matcher.group(1)) : -1;
  }
});

/**
 * Given a String the method uses Regex to check if the String only contains numeric characters
 *
 * @param s a String to check using regex
 * @return true if the String is valid
 */
public static boolean isNumeric(String s){
 Pattern p = Pattern.compile("^[\\p{Digit}\\s\\.]+$");
 Matcher m = p.matcher(s);
 return m.matches();
}

private String getFileName (String line) {
  Pattern pattern = Pattern.compile("(.*):([0-9])+:[0-9]+:");
  Matcher matcher = pattern.matcher(line);
  matcher.find();
  String fileName = matcher.groupCount() >= 2 ? matcher.group(1).trim() : null;
  if (fileName == null) return null;
  int index = fileName.indexOf(" ");
  if (index != -1)
    return fileName.substring(index).trim();
  else
    return fileName;
}

/**
 * Given a String the method uses Regex to check if the String looks like an acronym
 *
 * @param s a String to check using regex
 * @return true if the String is valid
 */
public static boolean isAcronym(String s){
 Pattern p = Pattern.compile("^[\\p{Upper}]+$");
 Matcher m = p.matcher(s);
 return m.matches();
}