java.util.regex.Matcher
is new.
java.lang.Object
All Implemented Interfaces:
MatchResult
implements
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:
The matches method attempts to match the entire input sequence against the pattern.
The lookingAt method attempts to match the input sequence, starting at the beginning, against the pattern.
The find method scans the input sequence looking for the next subsequence that matches the pattern.
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 searches 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.
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.
| Method Summary | |
|---|---|
| Matcher |
appendReplacement
(
StringBuffer
sb,
String
replacement) Implements a non-terminal append-and-replace step. |
| StringBuffer |
appendTail
(
StringBuffer
sb) Implements a terminal append-and-replace step. |
|
MatchResult
|
asResult
Returns the
match state
this matcher as a
MatchResult
|
| int |
end
()
Returns the
offset after
character matched.
|
|
int
|
end
(int group)
Returns the offset after the last character of the subsequence captured by the given group during the previous match operation.
|
| boolean |
find
() Attempts to find the next subsequence of the input sequence that matches the pattern. |
| 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. |
| String |
group
() Returns the input subsequence matched by the previous match. |
| String |
group
(int group) Returns the input subsequence captured by the given group during the previous match operation. |
| int |
groupCount
() Returns the number of capturing groups in this matcher's pattern. |
| boolean |
hitEnd
Returns true if
end of
input
was hit by
search engine in
last match operation performed by this matcher.
|
| boolean |
lookingAt
Attempts to match the
sequence, starting at the beginning of the region,
|
|
boolean
|
matches
()
Attempts to match the entire region against the pattern.
|
| Pattern |
pattern
() Returns the pattern that is interpreted by this matcher. |
|
static
String
|
quoteReplacement
(
String
Returns a literal replacement String for the specified String.
|
|
Matcher
|
region
(int start, int end)
Sets the limits of this matcher's region.
|
|
int
|
regionEnd
()
Reports the end index (exclusive) of this matcher's region.
|
|
int
|
regionStart
()
Reports the start index of this matcher's region.
|
| String |
replaceAll
(
String
replacement) Replaces every subsequence of the input sequence that matches the pattern with the given replacement string. |
| String |
replaceFirst
(
String
replacement) Replaces the first subsequence of the input sequence that matches the pattern with the given replacement string. |
|
boolean
|
requireEnd
()
Returns true if more input could change a positive match into a negative one.
|
| Matcher |
reset
() Resets this matcher. |
| Matcher |
reset
(
CharSequence
input) Resets this matcher with a new input sequence. |
| int |
start
() Returns the start index of the previous match. |
| int |
start
(int group) Returns the start index of the subsequence captured by the given group during the previous match operation. |
|
String
|
toString
()
Returns the string representation of this Matcher.
|
|
Matcher
|
usePattern
(
Pattern
Changes the
Pattern
that this
Matcher
uses to find matches with.
|
| Methods inherited from class java.lang. Object |
|---|
|
clone
,
equals
,
finalize
,
getClass
,
hashCode
,
notify
,
notifyAll
,
|
| Method Detail |
|---|
public Pattern pattern()
Returns:
The pattern for which this matcher was created
asResult
Returns the match state of this matcher as a
MatchResult
. The result is unaffected by subsequent operations performed upon this matcher.
Returns:
a MatchResult with the state of this matcher
usePattern
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.
Parameters:
newPattern - The new pattern used by this
Matcher
This matcher
Throws:
IllegalArgumentException
- If newPattern is
null
Since:
1.5
public Matcher reset()
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.
public Matcher reset(CharSequence input)
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.
public int start()
Specified by:
start
in interface
MatchResult
public int start(int group)
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() .
Specified by:
start
in interface
MatchResult
public int end()
offset after
matched.
Specified by:
end
in interface
MatchResult
offset after
matched
public int end(int group)
offset after
character
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() .
Specified by:
end
in interface
MatchResult
offset after
public String group()
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.
Specified by:
group
in interface
MatchResult
public String group(int group)
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 emtpy string in the input.
Specified by:
group
in interface
MatchResult
public int groupCount()
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.
Specified by:
groupCount
in interface
MatchResult
public boolean matches()
region
If the match succeeds then more information can be obtained via the start , end , and group methods.
region
public boolean find()
This method starts at the beginning of
this matcher's region,
the input sequence
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)
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.
This matcher's region is changed to start at the specified index.
public boolean lookingAt()
beginning of the region,
Like the
matches
method, this method always starts at the beginning of the
region;
input sequence;
unlike that method, it does not require that the entire
region
input sequence
be matched.
If the match succeeds then more information can be obtained via the start , end , and group methods.
quoteReplacement
Returns a literal replacement String for the specified String. This method produces a String that will work use as a literal replacement s in the appendReplacement method of the
Matcher
class. The String produced will match the sequence of characers in s treated as a literal sequence. Slashes ('\') and dollar signs ('$') will be given no special meaning.
Parameters:
s - The string to be literalized
Returns:
A literal string replacement
Since:
1.5
public Matcher appendReplacement(StringBuffer sb,
String replacement)
This method performs the following actions:
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 .
It appends the given replacement string to the string buffer.
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 $ g will be replaced by the result of evaluating group ( 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)
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.
public String replaceAll(String replacement)
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)
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.
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.
Parameters:
replacement - The replacement string
Returns:
The string constructed by replacing the first matching subsequence by the replacement string, substituting captured
Throws:
NullPointerException
- if replacement is null. subsequences as needed
region
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.
Only the match result is restricted by the region. The lookbehind construct can see over the starting point to match where appropriate. The lookahead construct can see beyoned the end of the region to match where appropriate. Zero length match constructs can see outside the region to determine if they should match at its boundaries. Anchors such as
^
and
$
will match at the beginning and end of the matcher's region. The boundary constructs for beginning and end of input match at the boundaries of a matcher's region.
Parameters:
start - The index to start searching at (inclusive)
end - The index to end searching at (exclusive)
Returns:
this Matcher
Throws:
IndexOutOfBoundsException
- If start or end is less than zero, if start is greater than the length of the input sequence, if end is greater than the length of the input sequence, or if start is greater than end.
Since:
1.5
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).
Returns:
The starting point of this matcher's region
Since:
1.5
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).
Returns:
the ending point of this
Matcher
's region
Since:
1.5
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.
Overrides:
toString
in class
Object
Returns:
The string representation of this matcher
Since:
1.5
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.
Returns:
true iff the end of input was hit in the last match; false otherwise
Since:
1.5
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.
Returns:
true iff more input could change a positive match into a negative one.
Since:
1.5