Matcher

public final class Matcher extends Object
implements MatchResult

J2ObjC modified: Synchronizations are removed because they were added in the Android sources to safeguard against hard-to-debug crashes from incorrect concurrent use of this class.

Public Method Summary

Matcher	appendReplacement(StringBuilder buffer, String replacement) Appends a literal part of the input plus a replacement for the current match to a given StringBuilder.
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.
StringBuilder	appendTail(StringBuilder buffer) Appends the (unmatched) remainder of the input to the given StringBuilder.
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(String name) Returns the offset after the last character of the subsequence captured by the given named-capturing group during the previous match operation.
int	end() Returns the offset after the last character matched.
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(int group) Returns the input subsequence captured by the given group during the previous match operation.
String	group(String name) Returns the input subsequence captured by the given named-capturing group during the previous match operation.
String	group() Returns the input subsequence matched by the previous match.
int	groupCount() Returns the number of capturing groups 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	lookingAt() Attempts to match the input sequence, starting at the beginning of the region, against the pattern.
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 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.
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(CharSequence input) Resets this matcher with a new input sequence.
Matcher	reset() Resets this matcher.
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(String name) Returns the start index of the subsequence captured by the given named-capturing group during the previous match operation.
MatchResult	toMatchResult() Returns the match state of this matcher as a MatchResult.
String	toString() Returns the string representation of this matcher.
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.

Protected Method Summary

void	finalize() Invoked when the garbage collector has detected that this instance is no longer reachable.

Inherited Method Summary

From class java.lang.Object

Object	clone() Creates and returns a copy of this Object.
boolean	equals(Object obj) Compares this instance with the specified object and indicates if they are equal.
void	finalize() Invoked when the garbage collector has detected that this instance is no longer reachable.
final Class<?>	getClass() Returns the unique instance of Class that represents this object's class.
int	hashCode() Returns an integer hash code for this object.
final void	notify() Causes a thread which is waiting on this object's monitor (by means of calling one of the wait() methods) to be woken up.
final void	notifyAll() Causes all threads which are waiting on this object's monitor (by means of calling one of the wait() methods) to be woken up.
String	toString() Returns a string containing a concise, human-readable description of this object.
final void	wait(long timeout, int nanos) Causes the calling thread to wait until another thread calls the notify() or notifyAll() method of this object or until the specified timeout expires.
final void	wait(long timeout) Causes the calling thread to wait until another thread calls the notify() or notifyAll() method of this object or until the specified timeout expires.
final void	wait() Causes the calling thread to wait until another thread calls the notify() or notifyAll() method of this object.

From interface java.util.regex.MatchResult

abstract int	end(int group) Returns the offset after the last character of the subsequence captured by the given group during this match.
abstract int	end() Returns the offset after the last character matched.
abstract String	group(int group) Returns the input subsequence captured by the given group during the previous match operation.
abstract String	group() Returns the input subsequence matched by the previous match.
abstract int	groupCount() Returns the number of capturing groups in this match result's pattern.
abstract int	start() Returns the start index of the match.
abstract int	start(int group) Returns the start index of the subsequence captured by the given group during this match.

Public Methods

public Matcher appendReplacement (StringBuilder buffer, String replacement)

Appends a literal part of the input plus a replacement for the current match to a given StringBuilder. The literal part is exactly the part of the input between the previous match and the current match. The method can be used in conjunction with find() and appendTail(StringBuilder) to walk through the input and replace all occurrences of the Pattern with something else.

Parameters

buffer	the StringBuilder to append to.
replacement	the replacement text.

Returns

• the Matcher itself.

Throws

IllegalStateException	if no successful match has been made.

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

Parameters

sb	The target string buffer
replacement	The replacement string

Returns

• This matcher

Throws

IllegalStateException	If no match has yet been attempted, or if the previous match operation failed
IllegalArgumentException	If the replacement string refers to a named-capturing group that does not exist in the pattern
IndexOutOfBoundsException	If the replacement string refers to a capturing group that does not exist in the pattern

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.

Parameters

sb	The target string buffer

Returns

• The target string buffer

public StringBuilder appendTail (StringBuilder buffer)

Appends the (unmatched) remainder of the input to the given StringBuilder. The method can be used in conjunction with find() and appendReplacement(StringBuilder, String) to walk through the input and replace all matches of the Pattern with something else.

Parameters

buffer

Returns

• the StringBuilder.

Throws

IllegalStateException	if no successful match has been made.

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().

Parameters

group	The index of a capturing group in this matcher's pattern

Returns

• The offset after the last character captured by the group, or -1 if the match was successful but the group itself did not match anything

Throws

IllegalStateException	If no match has yet been attempted, or if the previous match operation failed
IndexOutOfBoundsException	If there is no capturing group in the pattern with the given index

public int end (String name)

Returns the offset after the last character of the subsequence captured by the given named-capturing group during the previous match operation.

Parameters

name	The name of a named-capturing group in this matcher's pattern

Returns

• The offset after the last character captured by the group, or -1 if the match was successful but the group itself did not match anything

Throws

IllegalStateException	If no match has yet been attempted, or if the previous match operation failed
IllegalArgumentException	If there is no capturing group in the pattern with the given name

public int end ()

Returns the offset after the last character matched.

Returns

• The offset after the last character matched

Throws

IllegalStateException	If no match has yet been attempted, or if the previous match operation failed

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.

Returns

• true if, and only if, a subsequence of the input sequence matches this matcher's 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.

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.

Parameters

start	the index to start searching for a match

Returns

• true if, and only if, a subsequence of the input sequence starting at the given index matches this matcher's pattern

Throws

IndexOutOfBoundsException	If start is less than zero or if start is greater than the length of the input sequence.

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.

Parameters

group	The index of a capturing group in this matcher's pattern

Returns

• The (possibly empty) subsequence captured by the group during the previous match, or null if the group failed to match part of the input

Throws

IllegalStateException	If no match has yet been attempted, or if the previous match operation failed
IndexOutOfBoundsException	If there is no capturing group in the pattern with the given index

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.

Parameters

name	The name of a named-capturing group in this matcher's pattern

Returns

• The (possibly empty) subsequence captured by the named group during the previous match, or null if the group failed to match part of the input

Throws

IllegalStateException	If no match has yet been attempted, or if the previous match operation failed
IllegalArgumentException	If there is no capturing group in the pattern with the given name

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.

Returns

• The (possibly empty) subsequence matched by the previous match, in string form

Throws

IllegalStateException	If no match has yet been attempted, or if the previous match operation failed

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.

Returns

• The number of capturing groups in this matcher's pattern

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.

Returns

• true iff this matcher is using anchoring bounds, false otherwise.

See Also

• useAnchoringBounds(boolean)

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.

Returns

• true iff this matcher is using transparent bounds, false otherwise.

See Also

• useTransparentBounds(boolean)

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.

Returns

• true iff the end of input was hit in the last match; false otherwise

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.

Returns

• true if, and only if, a prefix of the input sequence matches this matcher's pattern

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.

Returns

• true if, and only if, the entire region sequence matches this matcher's pattern

public Pattern pattern ()

Returns the pattern that is interpreted by this matcher.

Returns

• The pattern for which this matcher was created

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.

Parameters

s	The string to be literalized

Returns

• A literal string replacement

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.

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.

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

Returns

• the ending point of this matcher's region

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

Returns

• The starting point of this matcher's region

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.

Parameters

replacement	The replacement string

Returns

• The string constructed by replacing each matching subsequence by the replacement string, substituting captured subsequences as needed

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.

Parameters

replacement	The replacement string

Returns

• The string constructed by replacing the first matching subsequence by the replacement string, substituting captured subsequences as needed

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.

Returns

• true iff more input could change a positive match into a negative one.

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.

Parameters

input	The new input character sequence

Returns

• This matcher

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.

Returns

• This matcher

public int start ()

Returns the start index of the previous match.

Returns

• The index of the first character matched

Throws

IllegalStateException	If no match has yet been attempted, or if the previous match operation failed

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().

Parameters

group	The index of a capturing group in this matcher's pattern

Returns

• The index of the first character captured by the group, or -1 if the match was successful but the group itself did not match anything

Throws

IllegalStateException	If no match has yet been attempted, or if the previous match operation failed
IndexOutOfBoundsException	If there is no capturing group in the pattern with the given index

public int start (String name)

Returns the start index of the subsequence captured by the given named-capturing group during the previous match operation.

Parameters

name	The name of a named-capturing group in this matcher's pattern

Returns

• The index of the first character captured by the group, or -1 if the match was successful but the group itself did not match anything

Throws

IllegalStateException	If no match has yet been attempted, or if the previous match operation failed
IllegalArgumentException	If there is no capturing group in the pattern with the given name

public MatchResult toMatchResult ()

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

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.

Returns

• The string representation of this matcher

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.

Parameters

b	a boolean indicating whether or not to use anchoring bounds.

Returns

• this matcher

See Also

• hasAnchoringBounds()

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.

Parameters

newPattern	The new pattern used by this matcher

Returns

• This matcher

Throws

IllegalArgumentException	If newPattern is null

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.

Parameters

b	a boolean indicating whether to use opaque or transparent regions

Returns

• this matcher

See Also

• hasTransparentBounds()

Protected Methods

protected void finalize ()

Invoked when the garbage collector has detected that this instance is no longer reachable. The default implementation does nothing, but this method can be overridden to free resources.

Note that objects that override finalize are significantly more expensive than objects that don't. Finalizers may be run a long time after the object is no longer reachable, depending on memory pressure, so it's a bad idea to rely on them for cleanup. Note also that finalizers are run on a single VM-wide finalizer thread, so doing blocking work in a finalizer is a bad idea. A finalizer is usually only necessary for a class that has a native peer and needs to call a native method to destroy that peer. Even then, it's better to provide an explicit close method (and implement Closeable), and insist that callers manually dispose of instances. This works well for something like files, but less well for something like a BigInteger where typical calling code would have to deal with lots of temporaries. Unfortunately, code that creates lots of temporaries is the worst kind of code from the point of view of the single finalizer thread.

If you must use finalizers, consider at least providing your own ReferenceQueue and having your own thread process that queue.

Unlike constructors, finalizers are not automatically chained. You are responsible for calling super.finalize() yourself.

Uncaught exceptions thrown by finalizers are ignored and do not terminate the finalizer thread. See Effective Java Item 7, "Avoid finalizers" for more.

Throws

Throwable