Index Methods

Index methods provide useful index values that show precisely where the match was found in the input string:

• 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.

Study Methods

Study methods review the input string and return a boolean indicating whether or not the pattern is found.

• 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.

Replacement Methods

Replacement methods are useful methods for replacing text in an input string.

• 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.

Using the start and end Methods

Here's an example, MatcherDemo.java,that counts the number of times the word "dog" appears in the input string.

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());
  }

You can see that this example uses word boundaries to ensure that the letters "d" "o" "g" are not merely a substring in a longer word. It also gives some useful information about where in the input string the match has occurred. The start method returns the start index of the subsequence captured by the given group during the prevIoUs match operation,and end returns the index of the last character matched,plus one.

Using the matches and lookingAt Methods

The matches and lookingAt methods both attempt to match an input sequence against a pattern. The difference,is that matchesrequires the entire input sequence to be matched,while lookingAt does not. Both methods always start at the beginning of the input string. Here's the full code, MatchesLooking.java:

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());
}

Using replaceFirst(String) and replaceAll(String)

The replaceFirst and replaceAll methods replace text that matches a given regular expression. As their names indicate, replaceFirstreplaces the first occurrence,and replaceAll replaces all occurences. Here's the ReplaceDemo.java code:

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);
}

In this first version,all occurrences of dog are replaced with cat. But why stop here? Rather than replace a simple literal likedog,you can replace text that matches any regular expression. The API for this method states that "given the regular expression a*b,the input aabfooaabfooabfoob,and the replacement string -,an invocation of this method on a matcher for that expression would yield the string -foo-foo-foo-."

Here's the ReplaceDemo2.java code:

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);
}

To replace only the first occurrence of the pattern,simply call replaceFirst instead of replaceAll. It accepts the same parameter.

Using appendReplacement(StringBuffer,String) and appendTail(StringBuffer)

The Matcher class also provides appendReplacement and appendTail methods for text replacement. The following example, RegexDemo.java,uses these two methods to achieve the same effect as replaceAll.

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());
}

Matcher Method Equivalents in java.lang.String

For convenience,the String class mimics a couple of Matcher methods as well:

• 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.

The following source code, RegexTestHarness2.java,updates our test harness to check for malformed regular expressions:

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(Pattern<a href="/tag/Syntax/" target="_blank" class="keywords">Syntax</a>Exception 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");
        }
    }
}

To run this test,enter ?i)foo as the regular expression. This mistake is a common scenario in which the programmer has forgotten the opening parenthesis in the embedded flag expression (?i). Doing so will produce the following results:

From this output,we can see that the Syntax error is a dangling Metacharacter (the question mark) at index 0. A missing opening parenthesis is the culprit。