* #### pattern
public [Pattern](../../../java/util/regex/Pattern.html "class in java.util.regex") pattern()
Returns the pattern that is interpreted by this matcher.
Returns:
The pattern for which this matcher was created
* #### toMatchResult
public [MatchResult](../../../java/util/regex/MatchResult.html "interface in java.util.regex") toMatchResult()
Returns the match state of this matcher as a [MatchResult](../../../java/util/regex/MatchResult.html "interface in java.util.regex"). The result is unaffected by subsequent operations performed upon this matcher.
Returns:
a `MatchResult` with the state of this matcher
Since:
1.5
* #### usePattern
public [Matcher](../../../java/util/regex/Matcher.html "class in java.util.regex") usePattern([Pattern](../../../java/util/regex/Pattern.html "class in java.util.regex") 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](../../../java/lang/IllegalArgumentException.html "class in java.lang")` \- If newPattern is `null`
Since:
1.5
* #### reset
public [Matcher](../../../java/util/regex/Matcher.html "class in java.util.regex") 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
* #### reset
public [Matcher](../../../java/util/regex/Matcher.html "class in java.util.regex") reset([CharSequence](../../../java/lang/CharSequence.html "interface in java.lang") 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
* #### start
public int start()
Returns the start index of the previous match.
Specified by:
`[start](../../../java/util/regex/MatchResult.html#start--)` in interface `[MatchResult](../../../java/util/regex/MatchResult.html "interface in java.util.regex")`
Returns:
The index of the first character matched
Throws:
`[IllegalStateException](../../../java/lang/IllegalStateException.html "class in java.lang")` \- If no match has yet been attempted, or if the previous match operation failed
* #### start
public int start(int group)
Returns the start index of the subsequence captured by the given group during the previous match operation.
[Capturing groups](Pattern.html#cg) 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](../../../java/util/regex/MatchResult.html#start-int-)` in interface `[MatchResult](../../../java/util/regex/MatchResult.html "interface in java.util.regex")`
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](../../../java/lang/IllegalStateException.html "class in java.lang")` \- If no match has yet been attempted, or if the previous match operation failed
`[IndexOutOfBoundsException](../../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- If there is no capturing group in the pattern with the given index
* #### start
public int start([String](../../../java/lang/String.html "class in java.lang") name)
Returns the start index of the subsequence captured by the given[named-capturing group](Pattern.html#groupname) 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](../../../java/lang/IllegalStateException.html "class in java.lang")` \- If no match has yet been attempted, or if the previous match operation failed
`[IllegalArgumentException](../../../java/lang/IllegalArgumentException.html "class in java.lang")` \- If there is no capturing group in the pattern with the given name
Since:
1.8
* #### end
public int end()
Returns the offset after the last character matched.
Specified by:
`[end](../../../java/util/regex/MatchResult.html#end--)` in interface `[MatchResult](../../../java/util/regex/MatchResult.html "interface in java.util.regex")`
Returns:
The offset after the last character matched
Throws:
`[IllegalStateException](../../../java/lang/IllegalStateException.html "class in java.lang")` \- If no match has yet been attempted, or if the previous match operation failed
* #### end
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](Pattern.html#cg) 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](../../../java/util/regex/MatchResult.html#end-int-)` in interface `[MatchResult](../../../java/util/regex/MatchResult.html "interface in java.util.regex")`
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](../../../java/lang/IllegalStateException.html "class in java.lang")` \- If no match has yet been attempted, or if the previous match operation failed
`[IndexOutOfBoundsException](../../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- If there is no capturing group in the pattern with the given index
* #### end
public int end([String](../../../java/lang/String.html "class in java.lang") name)
Returns the offset after the last character of the subsequence captured by the given [named-capturing group](Pattern.html#groupname) 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](../../../java/lang/IllegalStateException.html "class in java.lang")` \- If no match has yet been attempted, or if the previous match operation failed
`[IllegalArgumentException](../../../java/lang/IllegalArgumentException.html "class in java.lang")` \- If there is no capturing group in the pattern with the given name
Since:
1.8
* #### group
public [String](../../../java/lang/String.html "class in java.lang") 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.
Specified by:
`[group](../../../java/util/regex/MatchResult.html#group--)` in interface `[MatchResult](../../../java/util/regex/MatchResult.html "interface in java.util.regex")`
Returns:
The (possibly empty) subsequence matched by the previous match, in string form
Throws:
`[IllegalStateException](../../../java/lang/IllegalStateException.html "class in java.lang")` \- If no match has yet been attempted, or if the previous match operation failed
* #### group
public [String](../../../java/lang/String.html "class in java.lang") 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](Pattern.html#cg) 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.
Specified by:
`[group](../../../java/util/regex/MatchResult.html#group-int-)` in interface `[MatchResult](../../../java/util/regex/MatchResult.html "interface in java.util.regex")`
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](../../../java/lang/IllegalStateException.html "class in java.lang")` \- If no match has yet been attempted, or if the previous match operation failed
`[IndexOutOfBoundsException](../../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- If there is no capturing group in the pattern with the given index
* #### group
public [String](../../../java/lang/String.html "class in java.lang") group([String](../../../java/lang/String.html "class in java.lang") name)
Returns the input subsequence captured by the given[named-capturing group](Pattern.html#groupname) 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](../../../java/lang/IllegalStateException.html "class in java.lang")` \- If no match has yet been attempted, or if the previous match operation failed
`[IllegalArgumentException](../../../java/lang/IllegalArgumentException.html "class in java.lang")` \- If there is no capturing group in the pattern with the given name
Since:
1.7
* #### groupCount
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.
Specified by:
`[groupCount](../../../java/util/regex/MatchResult.html#groupCount--)` in interface `[MatchResult](../../../java/util/regex/MatchResult.html "interface in java.util.regex")`
Returns:
The number of capturing groups in this matcher's pattern
* #### matches
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
* #### find
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
* #### find
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()](../../../java/util/regex/Matcher.html#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](../../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- If start is less than zero or if start is greater than the length of the input sequence.
* #### lookingAt
public boolean lookingAt()
Attempts to match the input sequence, starting at the beginning of the region, against the pattern.
Like the [matches](../../../java/util/regex/Matcher.html#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
* #### quoteReplacement
public static [String](../../../java/lang/String.html "class in java.lang") quoteReplacement([String](../../../java/lang/String.html "class in java.lang") 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](../../../java/util/regex/Matcher.html "class in java.util.regex") 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
Since:
1.5
* #### appendReplacement
public [Matcher](../../../java/util/regex/Matcher.html "class in java.util.regex") appendReplacement([StringBuffer](../../../java/lang/StringBuffer.html "class in java.lang") sb,
[String](../../../java/lang/String.html "class in java.lang") 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()](../../../java/util/regex/Matcher.html#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()](../../../java/util/regex/Matcher.html#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)](../../../java/util/regex/Matcher.html#group-java.lang.String-) or [group(g)](../../../java/util/regex/Matcher.html#group-int-) 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](../../../java/util/regex/Matcher.html#appendTail-java.lang.StringBuffer-) and [find](../../../java/util/regex/Matcher.html#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](../../../java/lang/IllegalStateException.html "class in java.lang")` \- If no match has yet been attempted, or if the previous match operation failed
`[IllegalArgumentException](../../../java/lang/IllegalArgumentException.html "class in java.lang")` \- If the replacement string refers to a named-capturing group that does not exist in the pattern
`[IndexOutOfBoundsException](../../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- If the replacement string refers to a capturing group that does not exist in the pattern
* #### appendReplacement
public [Matcher](../../../java/util/regex/Matcher.html "class in java.util.regex") appendReplacement([StringBuilder](../../../java/lang/StringBuilder.html "class in java.lang") sb,
[String](../../../java/lang/String.html "class in java.lang") 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 builder. It stops after reading the last character preceding the previous match, that is, the character at index [start()](../../../java/util/regex/Matcher.html#start--) `-` `1`.
2. It appends the given replacement string to the string builder.
3. It sets the append position of this matcher to the index of the last character matched, plus one, that is, to [end()](../../../java/util/regex/Matcher.html#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](../../../java/util/regex/Matcher.html#group-int-)`(`_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 builder. 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](../../../java/util/regex/Matcher.html#appendTail-java.lang.StringBuffer-) and [find](../../../java/util/regex/Matcher.html#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");
> StringBuilder sb = new StringBuilder();
> while (m.find()) {
> m.appendReplacement(sb, "dog");
> }
> m.appendTail(sb);
> System.out.println(sb.toString());
Parameters:
`sb` \- The target string builder
`replacement` \- The replacement string
Returns:
This matcher
Throws:
`[IllegalStateException](../../../java/lang/IllegalStateException.html "class in java.lang")` \- If no match has yet been attempted, or if the previous match operation failed
`[IllegalArgumentException](../../../java/lang/IllegalArgumentException.html "class in java.lang")` \- If the replacement string refers to a named-capturing group that does not exist in the pattern
`[IndexOutOfBoundsException](../../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- If the replacement string refers to a capturing group that does not exist in the pattern
Since:
9
* #### appendTail
public [StringBuffer](../../../java/lang/StringBuffer.html "class in java.lang") appendTail([StringBuffer](../../../java/lang/StringBuffer.html "class in java.lang") 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](../../../java/util/regex/Matcher.html#appendReplacement-java.lang.StringBuffer-java.lang.String-) method in order to copy the remainder of the input sequence.
Parameters:
`sb` \- The target string buffer
Returns:
The target string buffer
* #### appendTail
public [StringBuilder](../../../java/lang/StringBuilder.html "class in java.lang") appendTail([StringBuilder](../../../java/lang/StringBuilder.html "class in java.lang") 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 builder. It is intended to be invoked after one or more invocations of the [appendReplacement](../../../java/util/regex/Matcher.html#appendReplacement-java.lang.StringBuffer-java.lang.String-) method in order to copy the remainder of the input sequence.
Parameters:
`sb` \- The target string builder
Returns:
The target string builder
Since:
9
* #### replaceAll
public [String](../../../java/lang/String.html "class in java.lang") replaceAll([String](../../../java/lang/String.html "class in java.lang") 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](../../../java/util/regex/Matcher.html#appendReplacement-java.lang.StringBuffer-java.lang.String-) 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
* #### replaceAll
public [String](../../../java/lang/String.html "class in java.lang") replaceAll([Function](../../../java/util/function/Function.html "interface in java.util.function")<[MatchResult](../../../java/util/regex/MatchResult.html "interface in java.util.regex"),[String](../../../java/lang/String.html "class in java.lang")> replacer)
Replaces every subsequence of the input sequence that matches the pattern with the result of applying the given replacer function to the match result of this matcher corresponding to that subsequence. Exceptions thrown by the function are relayed to the caller.
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 applying the replacer function that returns a replacement string. Each replacement string may contain references to captured subsequences as in the [appendReplacement](../../../java/util/regex/Matcher.html#appendReplacement-java.lang.StringBuffer-java.lang.String-) method.
Note that backslashes (`\`) and dollar signs (`$`) in a 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 function`mr -> mr.group().toUpperCase()`, an invocation of this method on a matcher for that expression would yield the string`"zzzDOGzzzDOGzzz"`.
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.
The replacer function should not modify this matcher's state during replacement. This method will, on a best-effort basis, throw a[ConcurrentModificationException](../../../java/util/ConcurrentModificationException.html "class in java.util") if such modification is detected.
The state of each match result passed to the replacer function is guaranteed to be constant only for the duration of the replacer function call and only if the replacer function does not modify this matcher's state.
Implementation Note:
This implementation applies the replacer function to this matcher, which is an instance of `MatchResult`.
Parameters:
`replacer` \- The function to be applied to the match result of this matcher that returns a replacement string.
Returns:
The string constructed by replacing each matching subsequence with the result of applying the replacer function to that matched subsequence, substituting captured subsequences as needed.
Throws:
`[NullPointerException](../../../java/lang/NullPointerException.html "class in java.lang")` \- if the replacer function is null
`[ConcurrentModificationException](../../../java/util/ConcurrentModificationException.html "class in java.util")` \- if it is detected, on a best-effort basis, that the replacer function modified this matcher's state
Since:
9
* #### results
public [Stream](../../../java/util/stream/Stream.html "interface in java.util.stream")<[MatchResult](../../../java/util/regex/MatchResult.html "interface in java.util.regex")> results()
Returns a stream of match results for each subsequence of the input sequence that matches the pattern. The match results occur in the same order as the matching subsequences in the input sequence.
Each match result is produced as if by [toMatchResult()](../../../java/util/regex/Matcher.html#toMatchResult--).
This method does not reset this matcher. Matching starts on initiation of the terminal stream operation either at the beginning of this matcher's region, or, if the matcher has not since been reset, at the first character not matched by a previous match.
If the matcher is to be used for further matching operations after the terminal stream operation completes then it should be first reset.
This matcher's state should not be modified during execution of the returned stream's pipeline. The returned stream's source`Spliterator` is _fail-fast_ and will, on a best-effort basis, throw a [ConcurrentModificationException](../../../java/util/ConcurrentModificationException.html "class in java.util") if such modification is detected.
Returns:
a sequential stream of match results.
Since:
9
* #### replaceFirst
public [String](../../../java/lang/String.html "class in java.lang") replaceFirst([String](../../../java/lang/String.html "class in java.lang") 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](../../../java/util/regex/Matcher.html#appendReplacement-java.lang.StringBuffer-java.lang.String-) 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
* #### replaceFirst
public [String](../../../java/lang/String.html "class in java.lang") replaceFirst([Function](../../../java/util/function/Function.html "interface in java.util.function")<[MatchResult](../../../java/util/regex/MatchResult.html "interface in java.util.regex"),[String](../../../java/lang/String.html "class in java.lang")> replacer)
Replaces the first subsequence of the input sequence that matches the pattern with the result of applying the given replacer function to the match result of this matcher corresponding to that subsequence. Exceptions thrown by the replace function are relayed to the caller.
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 applying the replacer function that returns a replacement string. The replacement string may contain references to captured subsequences as in the [appendReplacement](../../../java/util/regex/Matcher.html#appendReplacement-java.lang.StringBuffer-java.lang.String-) 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 function`mr -> mr.group().toUpperCase()`, an invocation of this method on a matcher for that expression would yield the string`"zzzDOGzzzdogzzz"`.
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.
The replacer function should not modify this matcher's state during replacement. This method will, on a best-effort basis, throw a[ConcurrentModificationException](../../../java/util/ConcurrentModificationException.html "class in java.util") if such modification is detected.
The state of the match result passed to the replacer function is guaranteed to be constant only for the duration of the replacer function call and only if the replacer function does not modify this matcher's state.
Implementation Note:
This implementation applies the replacer function to this matcher, which is an instance of `MatchResult`.
Parameters:
`replacer` \- The function to be applied to the match result of this matcher that returns a replacement string.
Returns:
The string constructed by replacing the first matching subsequence with the result of applying the replacer function to the matched subsequence, substituting captured subsequences as needed.
Throws:
`[NullPointerException](../../../java/lang/NullPointerException.html "class in java.lang")` \- if the replacer function is null
`[ConcurrentModificationException](../../../java/util/ConcurrentModificationException.html "class in java.util")` \- if it is detected, on a best-effort basis, that the replacer function modified this matcher's state
Since:
9
* #### region
public [Matcher](../../../java/util/regex/Matcher.html "class in java.util.regex") 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](../../../java/util/regex/Matcher.html#useTransparentBounds-boolean-) and[useAnchoringBounds](../../../java/util/regex/Matcher.html#useAnchoringBounds-boolean-)), 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](../../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- 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
public int regionStart()
Reports the start index of this matcher's region. The searches this matcher conducts are limited to finding matches within [regionStart](../../../java/util/regex/Matcher.html#regionStart--) (inclusive) and[regionEnd](../../../java/util/regex/Matcher.html#regionEnd--) (exclusive).
Returns:
The starting point of this matcher's region
Since:
1.5
* #### regionEnd
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](../../../java/util/regex/Matcher.html#regionStart--) (inclusive) and[regionEnd](../../../java/util/regex/Matcher.html#regionEnd--) (exclusive).
Returns:
the ending point of this matcher's region
Since:
1.5
* #### hasTransparentBounds
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](../../../java/util/regex/Matcher.html#useTransparentBounds-boolean-) 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.
Since:
1.5
See Also:
[useTransparentBounds(boolean)](../../../java/util/regex/Matcher.html#useTransparentBounds-boolean-)
* #### useTransparentBounds
public [Matcher](../../../java/util/regex/Matcher.html "class in java.util.regex") 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
Since:
1.5
See Also:
[hasTransparentBounds()](../../../java/util/regex/Matcher.html#hasTransparentBounds--)
* #### hasAnchoringBounds
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](../../../java/util/regex/Matcher.html#useAnchoringBounds-boolean-) 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.
Since:
1.5
See Also:
[useAnchoringBounds(boolean)](../../../java/util/regex/Matcher.html#useAnchoringBounds-boolean-)
* #### useAnchoringBounds
public [Matcher](../../../java/util/regex/Matcher.html "class in java.util.regex") 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
Since:
1.5
See Also:
[hasAnchoringBounds()](../../../java/util/regex/Matcher.html#hasAnchoringBounds--)
* #### toString
public [String](../../../java/lang/String.html "class in java.lang") 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](../../../java/lang/Object.html#toString--)` in class `[Object](../../../java/lang/Object.html "class in java.lang")`
Returns:
The string representation of this matcher
Since:
1.5
* #### hitEnd
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
Since:
1.5
* #### requireEnd
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.
Since:
1.5