Regular Expressions --正则表达式官方教程

• A Pattern object is a compiled representation of a regular expression. The Pattern class provides no public constructors. To create a pattern,you must first invoke one of its public static compile methods,which will then return a Pattern object. These methods accept a regular expression as the first argument; the first few lessons of this trail will teach you the required syntax.
• A Matcher object is the engine that interprets the pattern and performs match operations against an input string. Like thePattern class, Matcher defines no public constructors. You obtain a Matcher object by invoking the matcher method on a Patternobject.
• A PatternSyntaxException object is an unchecked exception that indicates a syntax error in a regular expression pattern.

Negation

Ranges

Unions

Intersections

Subtraction

• \d matches all digits
• \s matches spaces
• \w matches word characters

• \D matches non-digits
• \S matches non-spaces
• \W matches non-word characters

• public int start(int group): Returns the start index of the subsequence captured by the given group during the previous match operation.
• public int end (int group): Returns the index of the last character,plus one,of the subsequence captured by the given group during the previous match operation.
• public String group (int group): Returns the input subsequence captured by the given group during the previous match operation.

• Pattern.CANON_EQ Enables canonical equivalence. When this flag is specified,two characters will be considered to match if,and only if,their full canonical decompositions match. The expression "a\u030A",will match the string "\u00E5" when this flag is specified. By default,matching does not take canonical equivalence into account. Specifying this flag may impose a performance penalty.
• Pattern.CASE_INSENSITIVE Enables case-insensitive matching. By default,case-insensitive matching assumes that only characters in the US-ASCII charset are being matched. Unicode-aware case-insensitive matching can be enabled by specifying the UNICODE_CASE flag in conjunction with this flag. Case-insensitive matching can also be enabled via the embedded flag expression (?i). Specifying this flag may impose a slight performance penalty.
• Pattern.COMMENTS Permits whitespace and comments in the pattern. In this mode,whitespace is ignored,and embedded comments starting with # are ignored until the end of a line. Comments mode can also be enabled via the embedded flag expression (?x).
• Pattern.DOTALL Enables dotall mode. In dotall mode,the expression . matches any character,including a line terminator. By default this expression does not match line terminators. Dotall mode can also be enabled via the embedded flag expression (?s). (The s is a mnemonic for "single-line" mode,which is what this is called in Perl.)
• Pattern.LITERAL Enables literal parsing of the pattern. When this flag is specified then the input string that specifies the pattern is treated as a sequence of literal characters. Metacharacters or escape sequences in the input sequence will be given no special meaning. The flags CASE_INSENSITIVE and UNICODE_CASE retain their impact on matching when used in conjunction with this flag. The other flags become superfluous. There is no embedded flag character for enabling literal parsing.
• Pattern.MULTILINE Enables multiline mode. In multiline mode the expressions ^ and $ match just after or just before,respectively,a line terminator or the end of the input sequence. By default these expressions only match at the beginning and the end of the entire input sequence. Multiline mode can also be enabled via the embedded flag expression (?m).
• Pattern.UNICODE_CASE Enables Unicode-aware case folding. When this flag is specified then case-insensitive matching,when enabled by the CASE_INSENSITIVE flag,is done in a manner consistent with the Unicode Standard. By default,case-insensitive matching assumes that only characters in the US-ASCII charset are being matched. Unicode-aware case folding can also be enabled via the embedded flag expression (?u). Specifying this flag may impose a performance penalty.
• Pattern.UNIX_LINES Enables UNIX lines mode. In this mode,only the '\n' line terminator is recognized in the behavior of ., ^,and$. UNIX lines mode can also be enabled via the embedded flag expression (?d).

private static final String REGEX = ":";
private static final String INPUT =
    "one:two:three:four:five";

public static void main(String[] args) {
    Pattern p = Pattern.compile(REGEX);
    String[] items = p.split(INPUT);
    for(String s : items) {
        System.out.println(s);
    }
}

private static final String REGEX = "\\d";
private static final String INPUT =
    "one9two4three7four1five";

public static void main(String[] args) {
    Pattern p = Pattern.compile(REGEX);
    String[] items = p.split(INPUT);
    for(String s : items) {
        System.out.println(s);
    }
}

• public static String quote(String s) Returns a literal pattern String for the specified String. This method produces a String that can be used to create a Pattern that would match String s as if it were a literal pattern. Metacharacters or escape sequences in the input sequence will be given no special meaning.
• public String toString() Returns the String representation of this pattern. This is the regular expression from which this pattern was compiled.

• public boolean matches(String regex): Tells whether or not this string matches the given regular expression. An invocation of this method of the form str.matches(regex) yields exactly the same result as the expression Pattern.matches(regex, str).
• public String[] split(String regex,int limit): Splits this string around matches of the given regular expression. An invocation of this method of the form str.split(regex, n) yields the same result as the expression Pattern.compile(regex).split(str, n)
• public String[] split(String regex): Splits this string around matches of the given regular expression. This method works the same as if you invoked the two-argument split method with the given expression and a limit argument of zero. Trailing empty strings are not included in the resulting array.

• public String replace(CharSequence target,CharSequence replacement): Replaces each substring of this string that matches the literal target sequence with the specified literal replacement sequence. The replacement proceeds from the beginning of the string to the end,replacing "aa" with "b" in the string "aaa" will result in "ba" rather than "ab".

• public int start(): Returns the start index of the previous match.
• public int start(int group): Returns the start index of the subsequence captured by the given group during the previous match operation.
• public int end(): Returns the offset after the last character matched.
• public int end(int group): Returns the offset after the last character of the subsequence captured by the given group during the previous match operation.

• public boolean lookingAt(): Attempts to match the input sequence,starting at the beginning of the region,against the pattern.
• public boolean find(): Attempts to find the next subsequence of the input sequence that matches the pattern.
• public boolean find(int start): Resets this matcher and then attempts to find the next subsequence of the input sequence that matches the pattern,starting at the specified index.
• public boolean matches(): Attempts to match the entire region against the pattern.

• public Matcher appendReplacement(StringBuffer sb,String replacement): Implements a non-terminal append-and-replace step.
• public StringBuffer appendTail(StringBuffer sb): Implements a terminal append-and-replace step.
• public String replaceAll(String replacement): Replaces every subsequence of the input sequence that matches the pattern with the given replacement string.
• public String replaceFirst(String replacement): Replaces the first subsequence of the input sequence that matches the pattern with the given replacement string.
• public static String quoteReplacement(String s): Returns a literal replacement String for the specified String. This method produces aString that will work as a literal replacement s in the appendReplacement method of the Matcher class. The String produced will match the sequence of characters in s treated as a literal sequence. Slashes ('\') and dollar signs ('$') will be given no special meaning.

private static final String REGEX =
    "\\bdog\\b";
private static final String INPUT =
    "dog dog dog doggie dogg";

public static void main(String[] args) {
   Pattern p = Pattern.compile(REGEX);
   //  get a matcher object
   Matcher m = p.matcher(INPUT);
   int count = 0;
   while(m.find()) {
       count++;
       System.out.println("Match number "
                          + count);
       System.out.println("start(): "
                          + m.start());
       System.out.println("end(): "
                          + m.end());
  }

private static final String REGEX = "foo";
private static final String INPUT =
    "fooooooooooooooooo";
private static Pattern pattern;
private static Matcher matcher;

public static void main(String[] args) {

    // Initialize
    pattern = Pattern.compile(REGEX);
    matcher = pattern.matcher(INPUT);

    System.out.println("Current REGEX is: "
                       + REGEX);
    System.out.println("Current INPUT is: "
                       + INPUT);

    System.out.println("lookingAt(): "
        + matcher.lookingAt());
    System.out.println("matches(): "
        + matcher.matches());
}

private static String REGEX = "dog";
private static String INPUT =
    "The dog says meow. All dogs say meow.";
private static String REPLACE = "cat";

public static void main(String[] args) {
    Pattern p = Pattern.compile(REGEX);
    // get a matcher object
    Matcher m = p.matcher(INPUT);
    INPUT = m.replaceAll(REPLACE);
    System.out.println(INPUT);
}

private static String REGEX = "a*b";
private static String INPUT =
    "aabfooaabfooabfoob";
private static String REPLACE = "-";

public static void main(String[] args) {
    Pattern p = Pattern.compile(REGEX);
    // get a matcher object
    Matcher m = p.matcher(INPUT);
    INPUT = m.replaceAll(REPLACE);
    System.out.println(INPUT);
}

private static String REGEX = "a*b";
private static String INPUT = "aabfooaabfooabfoob";
private static String REPLACE = "-";

public static void main(String[] args) {
    Pattern p = Pattern.compile(REGEX);
    Matcher m = p.matcher(INPUT); // get a matcher object
    StringBuffer sb = new StringBuffer();
    while(m.find()){
        m.appendReplacement(sb,REPLACE);
    }
    m.appendTail(sb);
    System.out.println(sb.toString());
}

• public String replaceFirst(String regex,String replacement): Replaces the first substring of this string that matches the given regular expression with the given replacement. An invocation of this method of the form str.replaceFirst(regex, repl) yields exactly the same result as the expression Pattern.compile(regex).matcher(str).replaceFirst(repl)
• public String replaceAll(String regex,String replacement): Replaces each substring of this string that matches the given regular expression with the given replacement. An invocation of this method of the form str.replaceAll(regex, repl) yields exactly the same result as the expression Pattern.compile(regex).matcher(str).replaceAll(repl)

• public String getDescription(): Retrieves the description of the error.
• public int getIndex(): Retrieves the error index.
• public String getPattern(): Retrieves the erroneous regular expression pattern.
• public String getMessage(): Returns a multi-line string containing the description of the syntax error and its index,the erroneous regular-expression pattern,and a visual indication of the error index within the pattern.

public static void main(String[] args){
    Pattern pattern = null;
    Matcher matcher = null;

    Console console = System.console();
    if (console == null) {
        System.err.println("No console.");
        System.exit(1);
    }
    while (true) {
        try{
            pattern = 
            Pattern.compile(console.readLine("%nEnter your regex: "));

            matcher = 
            pattern.matcher(console.readLine("Enter input string to search: "));
        }
        catch(PatternSyntaxException pse){
            console.format("There is a problem" +
                           " with the regular expression!%n");
            console.format("The pattern in question is: %s%n",pse.getPattern());
            console.format("The description is: %s%n",pse.getDescription());
            console.format("The message is: %s%n",pse.getMessage());
            console.format("The index is: %s%n",pse.getIndex());
            System.exit(0);
        }
        boolean found = false;
        while (matcher.find()) {
            console.format("I found the text" +
                " \"%s\" starting at " +
                "index %d and ending at index %d.%n",matcher.end());
            found = true;
        }
        if(!found){
            console.format("No match found.%n");
        }
    }
}