Save This Page
Home » openjdk-7 » java » util » regex » [javadoc | source]
java.util.regex
public final class: Matcher [javadoc | source]
java.lang.Object
   java.util.regex.Matcher

All Implemented Interfaces:
    MatchResult

An engine that performs match operations on a character sequence by interpreting a Pattern .

A matcher is created from a pattern by invoking the pattern's matcher method. Once created, a matcher can be used to perform three different kinds of match operations:

Each of these methods returns a boolean indicating success or failure. More information about a successful match can be obtained by querying the state of the matcher.

A matcher finds matches in a subset of its input called the region. By default, the region contains all of the matcher's input. The region can be modified via the region method and queried via the regionStart and regionEnd methods. The way that the region boundaries interact with some pattern constructs can be changed. See useAnchoringBounds and useTransparentBounds for more details.

This class also defines methods for replacing matched subsequences with new strings whose contents can, if desired, be computed from the match result. The appendReplacement and appendTail methods can be used in tandem in order to collect the result into an existing string buffer, or the more convenient replaceAll method can be used to create a string in which every matching subsequence in the input sequence is replaced.

The explicit state of a matcher includes the start and end indices of the most recent successful match. It also includes the start and end indices of the input subsequence captured by each capturing group in the pattern as well as a total count of such subsequences. As a convenience, methods are also provided for returning these captured subsequences in string form.

The explicit state of a matcher is initially undefined; attempting to query any part of it before a successful match will cause an IllegalStateException to be thrown. The explicit state of a matcher is recomputed by every match operation.

The implicit state of a matcher includes the input character sequence as well as the append position, which is initially zero and is updated by the appendReplacement method.

A matcher may be reset explicitly by invoking its #reset() method or, if a new input sequence is desired, its reset(CharSequence) method. Resetting a matcher discards its explicit state information and sets the append position to zero.

Instances of this class are not safe for use by multiple concurrent threads.

Field Summary
 Pattern parentPattern    The Pattern object that created this Matcher. 
 int[] groups    The storage used by groups. They may contain invalid values if a group was skipped during the matching. 
 int from    The range within the sequence that is to be matched. Anchors will match at these "hard" boundaries. Changing the region changes these values. 
 int to     
 int lookbehindTo    Lookbehind uses this value to ensure that the subexpression match ends at the point where the lookbehind was encountered. 
 CharSequence text    The original string being matched. 
static final  int ENDANCHOR    Matcher state used by the last node. NOANCHOR is used when a match does not have to consume all of the input. ENDANCHOR is the mode used for matching all the input. 
static final  int NOANCHOR     
 int acceptMode     
 int first    The range of string that last matched the pattern. If the last match failed then first is -1; last initially holds 0 then it holds the index of the end of the last match (which is where the next search starts). 
 int last     
 int oldLast    The end index of what matched in the last match operation. 
 int lastAppendPosition    The index of the last position appended in a substitution. 
 int[] locals    Storage used by nodes to tell what repetition they are on in a pattern, and where groups begin. The nodes themselves are stateless, so they rely on this field to hold state during a match. 
 boolean hitEnd    Boolean indicating whether or not more input could change the results of the last match. If hitEnd is true, and a match was found, then more input might cause a different match to be found. If hitEnd is true and a match was not found, then more input could cause a match to be found. If hitEnd is false and a match was found, then more input will not change the match. If hitEnd is false and a match was not found, then more input will not cause a match to be found. 
 boolean requireEnd    Boolean indicating whether or not more input could change a positive match into a negative one. If requireEnd is true, and a match was found, then more input could cause the match to be lost. If requireEnd is false and a match was found, then more input might change the match but the match won't be lost. If a match was not found, then requireEnd has no meaning. 
 boolean transparentBounds    If transparentBounds is true then the boundaries of this matcher's region are transparent to lookahead, lookbehind, and boundary matching constructs that try to see beyond them. 
 boolean anchoringBounds    If anchoringBounds is true then the boundaries of this matcher's region match anchors such as ^ and $. 
Constructor:
 Matcher() 
 Matcher(Pattern parent,
    CharSequence text) 
    All matchers have the state used by Pattern during a match.
Method from java.util.regex.Matcher Summary:
appendReplacement,   appendTail,   charAt,   end,   end,   find,   find,   getSubSequence,   getTextLength,   group,   group,   group,   groupCount,   hasAnchoringBounds,   hasTransparentBounds,   hitEnd,   lookingAt,   match,   matches,   pattern,   quoteReplacement,   region,   regionEnd,   regionStart,   replaceAll,   replaceFirst,   requireEnd,   reset,   reset,   search,   start,   start,   toMatchResult,   toString,   useAnchoringBounds,   usePattern,   useTransparentBounds
Methods from java.lang.Object:
clone,   equals,   finalize,   getClass,   hashCode,   notify,   notifyAll,   toString,   wait,   wait,   wait
Method from java.util.regex.Matcher Detail:
 public Matcher appendReplacement(StringBuffer sb,
    String replacement) 
    Implements a non-terminal append-and-replace step.

    This method performs the following actions:

    1. It reads characters from the input sequence, starting at the append position, and appends them to the given string buffer. It stops after reading the last character preceding the previous match, that is, the character at index #start()  - 1.

    2. It appends the given replacement string to the string buffer.

    3. It sets the append position of this matcher to the index of the last character matched, plus one, that is, to #end() .

    The replacement string may contain references to subsequences captured during the previous match: Each occurrence of ${name} or $g will be replaced by the result of evaluating the corresponding group(name) or group(g) respectively. For $g, the first number after the $ is always treated as part of the group reference. Subsequent numbers are incorporated into g if they would form a legal group reference. Only the numerals '0' through '9' are considered as potential components of the group reference. If the second group matched the string "foo", for example, then passing the replacement string "$2bar" would cause "foobar" to be appended to the string buffer. A dollar sign ($) may be included as a literal in the replacement string by preceding it with a backslash (\$).

    Note that backslashes (\) and dollar signs ($) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string. Dollar signs may be treated as references to captured subsequences as described above, and backslashes are used to escape literal characters in the replacement string.

    This method is intended to be used in a loop together with the appendTail and find methods. The following code, for example, writes one dog two dogs in the yard to the standard-output stream:

    Pattern p = Pattern.compile("cat");
    Matcher m = p.matcher("one cat two cats in the yard");
    StringBuffer sb = new StringBuffer();
    while (m.find()) {
        m.appendReplacement(sb, "dog");
    }
    m.appendTail(sb);
    System.out.println(sb.toString());
 public StringBuffer appendTail(StringBuffer sb) 
    Implements a terminal append-and-replace step.

    This method reads characters from the input sequence, starting at the append position, and appends them to the given string buffer. It is intended to be invoked after one or more invocations of the appendReplacement method in order to copy the remainder of the input sequence.

 char charAt(int i) 
    Returns this Matcher's input character at index i.
 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.

    Capturing groups are indexed from left to right, starting at one. Group zero denotes the entire pattern, so the expression m.end(0) is equivalent to m.end().

 public boolean find() 
    Attempts to find the next subsequence of the input sequence that matches the pattern.

    This method starts at the beginning of this matcher's region, or, if a previous invocation of the method was successful and the matcher has not since been reset, at the first character not matched by the previous match.

    If the match succeeds then more information can be obtained via the start, end, and group methods.

 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.

    If the match succeeds then more information can be obtained via the start, end, and group methods, and subsequent invocations of the #find() method will start at the first character not matched by this match.

 CharSequence getSubSequence(int beginIndex,
    int endIndex) 
    Generates a String from this Matcher's input in the specified range.
 int getTextLength() 
    Returns the end index of the text.
 public String group() 
    Returns the input subsequence matched by the previous match.

    For a matcher m with input sequence s, the expressions m.group() and s.substring(m.start(), m.end()) are equivalent.

    Note that some patterns, for example a*, match the empty string. This method will return the empty string when the pattern successfully matches the empty string in the input.

 public String group(int group) 
    Returns the input subsequence captured by the given group during the previous match operation.

    For a matcher m, input sequence s, and group index g, the expressions m.group(g) and s.substring(m.start(g), m.end(g)) are equivalent.

    Capturing groups are indexed from left to right, starting at one. Group zero denotes the entire pattern, so the expression m.group(0) is equivalent to m.group().

    If the match was successful but the group specified failed to match any part of the input sequence, then null is returned. Note that some groups, for example (a*), match the empty string. This method will return the empty string when such a group successfully matches the empty string in the input.

 public String group(String name) 
    Returns the input subsequence captured by the given named-capturing group during the previous match operation.

    If the match was successful but the group specified failed to match any part of the input sequence, then null is returned. Note that some groups, for example (a*), match the empty string. This method will return the empty string when such a group successfully matches the empty string in the input.

 public int groupCount() 
    Returns the number of capturing groups in this matcher's pattern.

    Group zero denotes the entire pattern by convention. It is not included in this count.

    Any non-negative integer smaller than or equal to the value returned by this method is guaranteed to be a valid group index for this matcher.

 public boolean hasAnchoringBounds() 
    Queries the anchoring of region bounds for this matcher.

    This method returns true if this matcher uses anchoring bounds, false otherwise.

    See useAnchoringBounds for a description of anchoring bounds.

    By default, a matcher uses anchoring region boundaries.

 public boolean hasTransparentBounds() 
    Queries the transparency of region bounds for this matcher.

    This method returns true if this matcher uses transparent bounds, false if it uses opaque bounds.

    See useTransparentBounds for a description of transparent and opaque bounds.

    By default, a matcher uses opaque region boundaries.

 public boolean hitEnd() 

    Returns true if the end of input was hit by the search engine in the last match operation performed by this matcher.

    When this method returns true, then it is possible that more input would have changed the result of the last search.

 public boolean lookingAt() 
    Attempts to match the input sequence, starting at the beginning of the region, against the pattern.

    Like the matches method, this method always starts at the beginning of the region; unlike that method, it does not require that the entire region be matched.

    If the match succeeds then more information can be obtained via the start, end, and group methods.

 boolean match(int from,
    int anchor) 
    Initiates a search for an anchored match to a Pattern within the given bounds. The groups are filled with default values and the match of the root of the state machine is called. The state machine will hold the state of the match as it proceeds in this matcher.
 public boolean matches() 
    Attempts to match the entire region against the pattern.

    If the match succeeds then more information can be obtained via the start, end, and group methods.

 public Pattern pattern() 
    Returns the pattern that is interpreted by this matcher.
 public static String quoteReplacement(String s) 
    Returns a literal replacement String for the specified String. This method produces a String 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.
 public Matcher region(int start,
    int end) 
    Sets the limits of this matcher's region. The region is the part of the input sequence that will be searched to find a match. Invoking this method resets the matcher, and then sets the region to start at the index specified by the start parameter and end at the index specified by the end parameter.

    Depending on the transparency and anchoring being used (see useTransparentBounds and useAnchoringBounds ), certain constructs such as anchors may behave differently at or around the boundaries of the region.

 public int regionEnd() 
    Reports the end index (exclusive) of this matcher's region. The searches this matcher conducts are limited to finding matches within regionStart (inclusive) and regionEnd (exclusive).
 public int regionStart() 
    Reports the start index of this matcher's region. The searches this matcher conducts are limited to finding matches within regionStart (inclusive) and regionEnd (exclusive).
 public String replaceAll(String replacement) 
    Replaces every subsequence of the input sequence that matches the pattern with the given replacement string.

    This method first resets this matcher. It then scans the input sequence looking for matches of the pattern. Characters that are not part of any match are appended directly to the result string; each match is replaced in the result by the replacement string. The replacement string may contain references to captured subsequences as in the appendReplacement method.

    Note that backslashes (\) and dollar signs ($) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string. Dollar signs may be treated as references to captured subsequences as described above, and backslashes are used to escape literal characters in the replacement string.

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

    Invoking this method changes this matcher's state. If the matcher is to be used in further matching operations then it should first be reset.

 public String replaceFirst(String replacement) 
    Replaces the first subsequence of the input sequence that matches the pattern with the given replacement string.

    This method first resets this matcher. It then scans the input sequence looking for a match of the pattern. Characters that are not part of the match are appended directly to the result string; the match is replaced in the result by the replacement string. The replacement string may contain references to captured subsequences as in the appendReplacement method.

    Note that backslashes (\) and dollar signs ($) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string. Dollar signs may be treated as references to captured subsequences as described above, and backslashes are used to escape literal characters in the replacement string.

    Given the regular expression dog, the input "zzzdogzzzdogzzz", and the replacement string "cat", an invocation of this method on a matcher for that expression would yield the string "zzzcatzzzdogzzz".

    Invoking this method changes this matcher's state. If the matcher is to be used in further matching operations then it should first be reset.

 public boolean requireEnd() 

    Returns true if more input could change a positive match into a negative one.

    If this method returns true, and a match was found, then more input could cause the match to be lost. If this method returns false and a match was found, then more input might change the match but the match won't be lost. If a match was not found, then requireEnd has no meaning.

 public Matcher reset() 
    Resets this matcher.

    Resetting a matcher discards all of its explicit state information and sets its append position to zero. The matcher's region is set to the default region, which is its entire character sequence. The anchoring and transparency of this matcher's region boundaries are unaffected.

 public Matcher reset(CharSequence input) 
    Resets this matcher with a new input sequence.

    Resetting a matcher discards all of its explicit state information and sets its append position to zero. The matcher's region is set to the default region, which is its entire character sequence. The anchoring and transparency of this matcher's region boundaries are unaffected.

 boolean search(int from) 
    Initiates a search to find a Pattern within the given bounds. The groups are filled with default values and the match of the root of the state machine is called. The state machine will hold the state of the match as it proceeds in this matcher. Matcher.from is not set here, because it is the "hard" boundary of the start of the search which anchors will set to. The from param is the "soft" boundary of the start of the search, meaning that the regex tries to match at that index but ^ won't match there. Subsequent calls to the search methods start at a new "soft" boundary which is the end of the previous match.
 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.

    Capturing groups are indexed from left to right, starting at one. Group zero denotes the entire pattern, so the expression m.start(0) is equivalent to m.start().

 public MatchResult toMatchResult() 
    Returns the match state of this matcher as a MatchResult . The result is unaffected by subsequent operations performed upon this matcher.
 public String toString() 

    Returns the string representation of this matcher. The string representation of a Matcher contains information that may be useful for debugging. The exact format is unspecified.

 public Matcher useAnchoringBounds(boolean b) 
    Sets the anchoring of region bounds for this matcher.

    Invoking this method with an argument of true will set this matcher to use anchoring bounds. If the boolean argument is false, then non-anchoring bounds will be used.

    Using anchoring bounds, the boundaries of this matcher's region match anchors such as ^ and $.

    Without anchoring bounds, the boundaries of this matcher's region will not match anchors such as ^ and $.

    By default, a matcher uses anchoring region boundaries.

 public Matcher usePattern(Pattern newPattern) 
    Changes the Pattern that this Matcher uses to find matches with.

    This method causes this matcher to lose information about the groups of the last match that occurred. The matcher's position in the input is maintained and its last append position is unaffected.

 public Matcher useTransparentBounds(boolean b) 
    Sets the transparency of region bounds for this matcher.

    Invoking this method with an argument of true will set this matcher to use transparent bounds. If the boolean argument is false, then opaque bounds will be used.

    Using transparent bounds, the boundaries of this matcher's region are transparent to lookahead, lookbehind, and boundary matching constructs. Those constructs can see beyond the boundaries of the region to see if a match is appropriate.

    Using opaque bounds, the boundaries of this matcher's region are opaque to lookahead, lookbehind, and boundary matching constructs that may try to see beyond them. Those constructs cannot look past the boundaries so they will fail to match anything outside of the region.

    By default, a matcher uses opaque bounds.