|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectinfo.codesaway.util.regex.Matcher
public final class Matcher
An engine that performs match operations on a character sequence
by interpreting a
Pattern
.
This class is an extension
of Java's Matcher
class. Javadocs were copied and
appended with the added functionality.
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 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 theregion
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.
Constructor Summary | |
---|---|
Matcher(java.util.regex.Matcher matcher)
|
Method Summary | |
---|---|
Matcher |
appendReplacement(java.lang.StringBuffer sb,
java.lang.String replacement)
Implements a non-terminal append-and-replace step. |
java.lang.StringBuffer |
appendTail(java.lang.StringBuffer sb)
Implements a terminal append-and-replace step. |
boolean |
asBoolean()
Alias for find() . |
Matcher |
clone()
|
boolean |
containsKey(java.lang.Object key)
|
boolean |
containsValue(java.lang.Object value)
|
int |
end()
Returns the offset after the last 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. |
int |
end(java.lang.String group)
Returns the offset after the last character of the subsequence captured by the given group during the previous match operation. |
int |
end(java.lang.String groupName,
int occurrence)
Returns the offset after the last character of the subsequence captured by the given group during the previous match operation. |
java.util.Set<java.util.Map.Entry<java.lang.Integer,java.lang.String>> |
entrySet()
|
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. |
java.lang.String |
get(java.lang.Object key)
|
java.util.List |
getAt(java.util.Collection<?> indexes)
|
java.lang.Object |
getAt(int idx)
Alias for MatchResult.group(int) |
java.lang.String |
getAt(java.lang.String group)
Alias for MatchResult.group(String) |
java.util.Map.Entry<java.lang.Integer,java.lang.String> |
getEntry(int group)
|
java.lang.String |
getGroupName(int group)
Returns the group name (if any) for the specified group. |
java.util.List<MatchResult> |
getResults()
|
java.lang.String |
group()
Returns the input subsequence matched by the previous match. |
java.lang.String |
group(int group)
Returns the input subsequence captured by the given group during the previous match operation. |
java.lang.String |
group(int group,
java.lang.String defaultValue)
Returns the input subsequence captured by the given group during the previous match operation. |
java.lang.String |
group(java.lang.String group)
Returns the input subsequence captured by the given group during the previous match operation. |
java.lang.String |
group(java.lang.String groupName,
int occurrence)
Returns the input subsequence captured by the given group during the previous match operation. |
java.lang.String |
group(java.lang.String groupName,
int occurrence,
java.lang.String defaultValue)
Returns the input subsequence captured by the given group during the previous match operation. |
java.lang.String |
group(java.lang.String group,
java.lang.String defaultValue)
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. |
int |
groupCount(int group)
|
int |
groupCount(java.lang.String groupName)
Returns the number of capturing groups (with the given group name) in this matcher's pattern. |
boolean |
hasAnchoringBounds()
Queries the anchoring of region bounds for this matcher. |
boolean |
hasTransparentBounds()
Queries the transparency of region bounds for this matcher. |
boolean |
hitEnd()
Returns true if the end of input was hit by the search engine in the last match operation performed by this matcher. |
boolean |
isEmpty()
Returns whether the previous match matched the empty string. |
boolean |
isEmpty(int group)
Returns whether the specified group matched the empty string. |
boolean |
isEmpty(java.lang.String group)
Returns whether the specified group matched the empty string. |
boolean |
isEmpty(java.lang.String groupName,
int occurrence)
Returns whether the specified group matched the empty string. |
boolean |
isMatchResult()
|
java.util.Iterator<MatchResult> |
iterator()
Returns an Iterator which traverses each match. |
java.util.Set<java.lang.Integer> |
keySet()
|
boolean |
lookingAt()
Attempts to match the input sequence, starting at the beginning of the region, against the pattern. |
boolean |
matched()
Returns whether the match was successful. |
boolean |
matched(int group)
Returns whether the specified group matched any part of the input sequence. |
boolean |
matched(java.lang.String group)
Returns whether the specified group matched any part of the input sequence. |
boolean |
matched(java.lang.String groupName,
int occurrence)
Returns whether the specified group matched any part of the input sequence. |
boolean |
matches()
Attempts to match the entire region against the pattern. |
MatchResult |
next()
|
int |
occurrence(int groupIndex)
Returns the occurrence of the first matched group with the given index. |
int |
occurrence(java.lang.String groupName)
Returns the occurrence of the first matched group with the given name. |
Pattern |
pattern()
Returns the pattern that is interpreted by this matcher. |
static java.lang.String |
quoteReplacement(java.lang.String s)
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. |
java.lang.String |
replaceAll(java.lang.String replacement)
Replaces every subsequence of the input sequence that matches the pattern with the given replacement string. |
java.lang.String |
replaceFirst(java.lang.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(java.lang.CharSequence input)
Resets this matcher with a new input sequence. |
int |
size()
|
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. |
int |
start(java.lang.String group)
Returns the start index of the subsequence captured by the given group during the previous match operation. |
int |
start(java.lang.String groupName,
int occurrence)
Returns the start index of the subsequence captured by the given group during the previous match operation. |
java.lang.String |
text()
Returns the string being matched. |
MatchResult |
toMatchResult()
Returns the match state of this matcher as a MatchResult . |
java.lang.String |
toString()
Returns the string representation of this matcher. |
boolean |
treatNullAsEmptyString()
|
Matcher |
treatNullAsEmptyString(boolean treatNullAsEmptyString)
|
Matcher |
useAnchoringBounds(boolean b)
Sets the anchoring of region bounds for this matcher. |
Matcher |
usePattern(Pattern newPattern)
Changes the Pattern that this Matcher uses to find matches with. |
Matcher |
useTransparentBounds(boolean b)
Sets the transparency of region bounds for this matcher. |
java.util.List<java.lang.String> |
values()
|
Methods inherited from class java.lang.Object |
---|
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait |
Constructor Detail |
---|
public Matcher(java.util.regex.Matcher matcher)
matcher
- Method Detail |
---|
public Pattern pattern()
pattern
in interface MatchResult
public MatchResult toMatchResult()
MatchResult
.
The result is unaffected by subsequent operations performed upon this
matcher.
MatchResult
with the state of this matcherpublic Matcher clone()
clone
in class java.lang.Object
public boolean isMatchResult()
public Matcher usePattern(Pattern newPattern)
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.
newPattern
- The new pattern used by this matcher
java.lang.IllegalArgumentException
- If newPattern is nullpublic 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. The anchoring and transparency of this matcher's region boundaries are unaffected.
public Matcher reset(java.lang.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. The anchoring and transparency of this matcher's region boundaries are unaffected.
input
- The new input character sequence
public int start()
start
in interface MatchResult
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failedpublic 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().
start
in interface MatchResult
group
- The index of a capturing group in this matcher's pattern
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IndexOutOfBoundsException
- If there is no capturing group in the pattern
with the given indexpublic int start(java.lang.String group)
start
in interface MatchResult
group
- A capturing group in this matcher's pattern
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IllegalArgumentException
- If there is no capturing group in the pattern
of the given grouppublic int start(java.lang.String groupName, int occurrence)
An invocation of this convenience method of the form
m.start(groupName, occurrence)
behaves in exactly the same way as
m.start(groupName + "[" + occurrence + "]")
start
in interface MatchResult
groupName
- The group name for a capturing group in this matcher's patternoccurrence
- The occurrence of the specified group name
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IllegalArgumentException
- If there is no capturing group in the pattern
of the given grouppublic int end()
end
in interface MatchResult
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failedpublic int end(int group)
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().
end
in interface MatchResult
group
- The index of a capturing group in this matcher's pattern
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IndexOutOfBoundsException
- If there is no capturing group in the pattern
with the given indexpublic int end(java.lang.String group)
end
in interface MatchResult
group
- A capturing group in this matcher's pattern
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IllegalArgumentException
- If there is no capturing group in the pattern
of the given grouppublic int end(java.lang.String groupName, int occurrence)
An invocation of this convenience method of the form
m.end(groupName, occurrence)
behaves in exactly the same way as
m.end(groupName + "[" + occurrence + "]")
end
in interface MatchResult
groupName
- The group name for a capturing group in this matcher's patternoccurrence
- The occurrence of the specified group name
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IllegalArgumentException
- If there is no capturing group in the pattern
of the given grouppublic int occurrence(int groupIndex)
Branch reset patterns allow multiple capture groups with the same group index to exist. This method offers a way to determine which occurrence matched.
occurrence
in interface MatchResult
groupIndex
- the name of the group
public int occurrence(java.lang.String groupName)
Branch reset patterns and the Pattern.DUPLICATE_NAMES
flag
allow multiple capture groups with the same group name to exist.
This method offers a way to determine which occurrence matched.
occurrence
in interface MatchResult
groupName
- the name of the group
public java.lang.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.
group
in interface MatchResult
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failedpublic java.lang.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 empty string in the input.
group
in interface MatchResult
group
- The index of a capturing group in this matcher's pattern
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IndexOutOfBoundsException
- If there is no capturing group in the pattern
with the given indexpublic java.lang.String group(int group, java.lang.String defaultValue)
Capturing groups are indexed from left to right, starting at one. Group zero denotes the entire pattern, so the expression m.group(0, null) is equivalent to m.group().
If the match was successful but the group specified failed to match
any
part of the input sequence, then defaultValue is returned,
whereas group(int)
would return null
. Otherwise,
the return is equivalent to that of m.group(group).
As a note,
m.group(group, null)
behaves in exactly the same way as
m.group(group)
group
in interface MatchResult
group
- The index of a capturing group in this matcher's patterndefaultValue
- The string to return if group(int)
would return
null
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IndexOutOfBoundsException
- If there is no capturing group in the pattern
with the given indexgroup(int)
public java.lang.String group(java.lang.String 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.
group
in interface MatchResult
group
- A capturing group in this matcher's pattern
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IllegalArgumentException
- If there is no capturing group in the pattern
of the given grouppublic java.lang.String group(java.lang.String group, java.lang.String defaultValue)
If the match was successful but the group specified failed to match
any part of the input sequence, then defaultValue is returned,
whereas group(String)
would return null
. Otherwise,
the return is equivalent to that of m.group(group).
As a note,
m.group(group, null)
behaves in exactly the same way as
m.group(group)
group
in interface MatchResult
group
- A capturing group in this matcher's patterndefaultValue
- The string to return if group(String)
would return
null
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IllegalArgumentException
- If there is no capturing group in the pattern
of the given groupgroup(String)
public java.lang.String group(java.lang.String groupName, int occurrence)
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.
An invocation of this convenience method of the form
m.group(groupName, occurrence)
behaves in exactly the same way as
m.group(groupName + "[" + occurrence + "]")
group
in interface MatchResult
groupName
- The group name for a capturing group in this matcher's patternoccurrence
- The occurrence of the specified group name
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IllegalArgumentException
- If there is no capturing group in the pattern
of the given grouppublic java.lang.String group(java.lang.String groupName, int occurrence, java.lang.String defaultValue)
If the match was successful but the group specified failed to match
any part of the input sequence, then defaultValue is returned,
whereas group(String, int)
would return null
.
Otherwise, the return is equivalent to that of
m.group(groupName, occurrence).
As a note,
m.group(groupName, occurrence, null)
behaves in exactly the same way as
m.group(groupName, occurrence)
An invocation of this convenience method of the form
m.group(groupName, occurrence, defaultValue)
behaves in exactly the same way as
m.group(groupName + "[" + occurrence + "]", defaultValue)
group
in interface MatchResult
groupName
- The group name for a capturing group in this matcher's patternoccurrence
- The occurrence of the specified group namedefaultValue
- The string to return if group(String, int)
would
return null
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IllegalArgumentException
- If there is no capturing group in the pattern
of the given groupgroup(String, int)
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.
groupCount
in interface MatchResult
public int groupCount(int group)
groupCount
in interface MatchResult
public int groupCount(java.lang.String groupName)
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 occurrence (for a group, groupName[occurrence]) for this matcher.
If groupName
is the empty string, this method's return is
equal to the return from groupCount()
.
Note: unlike other methods, this method doesn't throw an exception if the specified group doesn't exist. Instead, zero is returned, since the number of groups with the given (non-existent) group name is zero.
groupCount
in interface MatchResult
groupName
- The group name for a capturing group in this matcher's pattern
public boolean matches()
If the match succeeds then more information can be obtained via the start, end, and group methods.
public boolean matched()
Note that some patterns, for example a*, match the empty
string. This method will return true
when the pattern
successfully matches the empty string in the input.
Note: unlike the other methods, this method won't throw an
exception if no match has been attempted - instead, false
will be returned. This method provides a way to check that a match has
been attempted, and that it succeeded.
matched
in interface MatchResult
true
if the match was successfulpublic boolean matched(int group)
Capturing groups are indexed from left to right, starting at one. Group zero denotes the entire pattern, so the expression m.matched(0) is equivalent to m.matched().
If the match was successful but the group specified failed to match
any part of the input sequence, then false is returned. Note
that some groups, for example (a*), match the empty string. This
method will return true
when such a group successfully
matches the empty string in the input.
matched
in interface MatchResult
group
- The index of a capturing group in this matcher's pattern
true
if in the previous match, the group matched
part of the input.
java.lang.IllegalStateException
- If no match has yet been attempted,
or if the previous match operation failed
java.lang.IndexOutOfBoundsException
- If there is no capturing group in the pattern
with the given indexpublic boolean matched(java.lang.String group)
If the match was successful but the group specified failed to match
any part of the input sequence, then false is returned. Note
that some groups, for example (a*), match the empty string. This
method will return true
when such a group successfully
matches the empty string in the input.
matched
in interface MatchResult
group
- A capturing group in this matcher's pattern
true
if in the previous match, the group matched
part of the input.
java.lang.IllegalStateException
- If no match has yet been attempted,
or if the previous match operation failed
java.lang.IllegalArgumentException
- If there is no capturing group in the pattern
of the given grouppublic boolean matched(java.lang.String groupName, int occurrence)
If the match was successful but the group specified failed to match
any part of the input sequence, then false is returned. Note
that some groups, for example (a*), match the empty string. This
method will return true
when such a group successfully
matches the empty string in the input.
An invocation of this convenience method of the form
m.matched(groupName, occurrence)
behaves in exactly the same way as
m.matched(groupName + "[" + occurrence + "]")
matched
in interface MatchResult
groupName
- The group name for a capturing group in this matcher's patternoccurrence
- The occurrence of the specified group name
true
if in the previous match, the group matched
part of the input.
java.lang.IllegalStateException
- If no match has yet been attempted,
or if the previous match operation failed
java.lang.IllegalArgumentException
- If there is no capturing group in the pattern
of the given grouppublic boolean isEmpty()
isEmpty
in interface MatchResult
true
if the previous match matched the empty string.
java.lang.IllegalStateException
- If no match has yet been attempted,
or if the previous match operation failedpublic boolean isEmpty(int group)
Capturing groups are indexed from left to right, starting at one. Group zero denotes the entire pattern, so the expression m.isEmpty(0) is equivalent to m.isEmpty().
If the match was successful but the group specified failed to match any part of the input sequence, then false is returned.
isEmpty
in interface MatchResult
group
- The index of a capturing group in this matcher's pattern
true
if in the previous match, the group matched
the empty string.
java.lang.IllegalStateException
- If no match has yet been attempted,
or if the previous match operation failed
java.lang.IndexOutOfBoundsException
- If there is no capturing group in the pattern
with the given indexpublic boolean isEmpty(java.lang.String group)
If the match was successful but the group specified failed to match any part of the input sequence, then false is returned.
isEmpty
in interface MatchResult
group
- A capturing group in this matcher's pattern
true
if in the previous match, the group matched
the empty string.
java.lang.IllegalStateException
- If no match has yet been attempted,
or if the previous match operation failed
java.lang.IllegalArgumentException
- If there is no capturing group in the pattern
of the given grouppublic boolean isEmpty(java.lang.String groupName, int occurrence)
If the match was successful but the group specified failed to match any part of the input sequence, then false is returned.
An invocation of this convenience method of the form
m.isEmpty(groupName, occurrence)
behaves in exactly the same way as
m.isEmpty(groupName + "[" + occurrence + "]")
isEmpty
in interface MatchResult
groupName
- The group name for a capturing group in this matcher's patternoccurrence
- The occurrence of the specified group name
true
if in the previous match, the group matched
the empty string.
java.lang.IllegalStateException
- If no match has yet been attempted,
or if the previous match operation failed
java.lang.IllegalArgumentException
- If there is no capturing group in the pattern
of the given grouppublic boolean find()
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)
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.
start
- 0-based start index
java.lang.IndexOutOfBoundsException
- If start is less than zero or if start is greater than the
length of the input sequence.public boolean lookingAt()
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.
public static java.lang.String quoteReplacement(java.lang.String s)
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.
s
- The string to be literalized
public Matcher appendReplacement(java.lang.StringBuffer sb, java.lang.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-outputSyntax 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());
sb
- The target string bufferreplacement
- The replacement string
java.lang.IllegalStateException
- If no match has yet been attempted, or if the previous match
operation failed
java.lang.IllegalArgumentException
- If the replacement string refers to a named-capturing
group that does not exist in the pattern
java.lang.IllegalArgumentException
- If the replacement string refers to a named-capturing
group that does not exist in the pattern
java.lang.IndexOutOfBoundsException
- If the replacement string refers to a capturing group
that does not exist in the patternpublic java.lang.StringBuffer appendTail(java.lang.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.
sb
- The target string buffer
public java.lang.String replaceAll(java.lang.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.
replacement
- The replacement string
public java.lang.String replaceFirst(java.lang.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.
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.
replacement
- The replacement string
public Matcher region(int start, int end)
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.
start
- The index to start searching at (inclusive)end
- The index to end searching at (exclusive)
java.lang.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.public int regionStart()
regionStart
(inclusive) and
regionEnd
(exclusive).
public int regionEnd()
regionStart
(inclusive) and
regionEnd
(exclusive).
public boolean hasTransparentBounds()
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.
useTransparentBounds(boolean)
public Matcher useTransparentBounds(boolean b)
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.
b
- a boolean indicating whether to use opaque or transparent
regions
hasTransparentBounds()
public boolean hasAnchoringBounds()
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.
useAnchoringBounds(boolean)
public Matcher useAnchoringBounds(boolean b)
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.
b
- a boolean indicating whether or not to use anchoring bounds.
hasAnchoringBounds()
public java.lang.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.
toString
in class java.lang.Object
public boolean hitEnd()
When this method returns true, then it is possible that more input would have changed the result of the last search.
public boolean requireEnd()
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 java.lang.String text()
text
in interface MatchResult
public java.lang.String getGroupName(int group)
If a match has been successful, this function's return is the group name associated with the given group for this match. This group name is match independent, except, possibly, when the group is part of a "branch reset" pattern.
If there is no successful match, this function's return is the group name, only in the case that it is match independent. The only case where the group name is not match independent is when the group is part of a "branch reset" subpattern, and there are at least two groups with the given number.
For example, in the pattern
(?|(?<group1a>1a)|(?<group1b>1b)
, the group name
for group 1 depends on whether the pattern matches "1a" or "1b". In this
case, an IllegalStateException is thrown, because a match is required to
determine the group name.
If there is more than one occurrence of the group, the returned group
name includes the occurrence - for example, myGroup[1]
. If
there is only one occurrence of the group, only the group name is
returned - for example, myGroup
.
getGroupName
in interface MatchResult
group
- The index of a capturing group in this matcher's pattern
null
if
the group has no associated group name
java.lang.IllegalStateException
- If the group name is match dependent, and no match has yet
been attempted, or if the previous match operation failedpublic boolean treatNullAsEmptyString()
treatNullAsEmptyString
in interface MatchResult
public Matcher treatNullAsEmptyString(boolean treatNullAsEmptyString)
treatNullAsEmptyString
- public boolean containsKey(java.lang.Object key)
containsKey
in interface MatchResult
java.lang.IllegalArgumentException
- If key is not a CharSequence
or
Number
ill
public boolean containsValue(java.lang.Object value)
containsValue
in interface MatchResult
public java.util.Set<java.util.Map.Entry<java.lang.Integer,java.lang.String>> entrySet()
entrySet
in interface MatchResult
public java.lang.String get(java.lang.Object key)
get
in interface MatchResult
public java.util.Set<java.lang.Integer> keySet()
keySet
in interface MatchResult
public int size()
size
in interface MatchResult
public java.util.List<java.lang.String> values()
values
in interface MatchResult
public java.util.Map.Entry<java.lang.Integer,java.lang.String> getEntry(int group)
public java.util.Iterator<MatchResult> iterator()
Iterator
which traverses each match.
iterator
in interface java.lang.Iterable<MatchResult>
matcher
- a Matcher object
Matcher.group()
public java.util.List<MatchResult> getResults()
public boolean asBoolean()
find()
.
Coerces a Matcher instance to a boolean value, for use in Groovy truth
asBoolean
in interface MatchResult
public java.lang.Object getAt(int idx)
MatchResult.group(int)
In Groovy, adds support the subscript operator, e.g. matcher[group], for a regex Matcher.
getAt
in interface MatchResult
public java.util.List getAt(java.util.Collection<?> indexes)
public java.lang.String getAt(java.lang.String group)
MatchResult.group(String)
In Groovy, adds support the subscript operator, e.g. matcher[group], for a regex Matcher.
getAt
in interface MatchResult
public MatchResult next()
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |