This section describes some additional useful methods of theMatcher
class. For convenience, the methods listed below are grouped according to functionality.Index Methods
Index methods provide useful index values that show precisely where the match was found in the input string:
public int start()
: Returns the start index of the previous match.public int start(int group)
: Returns the start index of the subsequence captured by the given group during the previous match operation.public int end()
: Returns the offset after the last character matched.public int end(int group)
: Returns the offset after the last character of the subsequence captured by the given group during the previous match operation.Study Methods
Study methods review the input string and return a boolean indicating whether or not the pattern is found.
public boolean lookingAt()
: Attempts to match the input sequence, starting at the beginning of the region, against the pattern.public boolean find()
: Attempts to find the next subsequence of the input sequence that matches the 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.public boolean matches()
: Attempts to match the entire region against the pattern.Replacement Methods
Replacement methods are useful methods for replacing text in an input string.
public Matcher appendReplacement(StringBuffer sb, String replacement)
: Implements a non-terminal append-and-replace step.public StringBuffer appendTail(StringBuffer sb)
: Implements a terminal append-and-replace step.public String replaceAll(String replacement)
: Replaces every subsequence of the input sequence that matches the pattern with the given replacement string.public String replaceFirst(String replacement)
: Replaces the first subsequence of the input sequence that matches the pattern with the given replacement string.public static String quoteReplacement(String s)
: Returns a literal replacementString
for the specifiedString
. This method produces aString
that will work as a literal replacements
in theappendReplacement
method of theMatcher
class. TheString
produced will match the sequence of characters ins
treated as a literal sequence. Slashes ('\'
) and dollar signs ('$'
) will be given no special meaning.Using the
Here's an example,start
andend
MethodsMatcherDemo.java
, that counts the number of times the word "dog" appears in the input string.import java.util.regex.Pattern; import java.util.regex.Matcher; public class MatcherDemo { private static final String REGEX = "\\bdog\\b"; private static final String INPUT = "dog dog dog doggie dogg"; public static void main(String[] args) { Pattern p = Pattern.compile(REGEX); Matcher m = p.matcher(INPUT); // get a matcher object int count = 0; while(m.find()) { count++; System.out.println("Match number "+count); System.out.println("start(): "+m.start()); System.out.println("end(): "+m.end()); } } }You can see that this example uses word boundaries to ensure that the lettersOUTPUT: Match number 1 start(): 0 end(): 3 Match number 2 start(): 4 end(): 7 Match number 3 start(): 8 end(): 11"d" "o" "g"
are not merely a substring in a longer word. It also gives some useful information about where in the input string the match has occurred. Thestart
method returns the start index of the subsequence captured by the given group during the previous match operation, andend
returns the index of the last character matched, plus one.Using the
Thematches
andlookingAt
Methodsmatches
andlookingAt
methods both attempt to match an input sequence against a pattern. The difference, however, is thatmatches
requires the entire input sequence to be matched, whilelookingAt
does not. Both methods always start at the beginning of the input string. Here's the full code,MatchesLooking.java
:import java.util.regex.Pattern; import java.util.regex.Matcher; public class MatchesLooking { private static final String REGEX = "foo"; private static final String INPUT = "fooooooooooooooooo"; private static Pattern pattern; private static Matcher matcher; public static void main(String[] args) { // Initialize pattern = Pattern.compile(REGEX); matcher = pattern.matcher(INPUT); System.out.println("Current REGEX is: "+REGEX); System.out.println("Current INPUT is: "+INPUT); System.out.println("lookingAt(): "+matcher.lookingAt()); System.out.println("matches(): "+matcher.matches()); } }Current REGEX is: foo Current INPUT is: fooooooooooooooooo lookingAt(): true matches(): falseUsing
ThereplaceFirst(String)
andreplaceAll(String)
replaceFirst
andreplaceAll
methods replace text that matches a given regular expression. As their names indicate,replaceFirst
replaces the first occurrence, andreplaceAll
replaces all occurences. Here's theReplaceDemo.java
code:import java.util.regex.Pattern; import java.util.regex.Matcher; public class ReplaceDemo { private static String REGEX = "dog"; private static String INPUT = "The dog says meow. All dogs say meow."; private static String REPLACE = "cat"; public static void main(String[] args) { Pattern p = Pattern.compile(REGEX); Matcher m = p.matcher(INPUT); // get a matcher object INPUT = m.replaceAll(REPLACE); System.out.println(INPUT); } }In this first version, all occurrences ofOUTPUT: The cat says meow. All cats say meow.dog
are replaced withcat
. But why stop here? Rather than replace a simple literal likedog
, you can replace text that matches any regular expression. The API for this method states that "given the regular expressiona*b
, the inputaabfooaabfooabfoob
, and the replacement string-
, an invocation of this method on a matcher for that expression would yield the string-foo-foo-foo-
."Here's the
ReplaceDemo2.java
code:import java.util.regex.Pattern; import java.util.regex.Matcher; public class ReplaceDemo2 { private static String REGEX = "a*b"; private static String INPUT = "aabfooaabfooabfoob"; private static String REPLACE = "-"; public static void main(String[] args) { Pattern p = Pattern.compile(REGEX); Matcher m = p.matcher(INPUT); // get a matcher object INPUT = m.replaceAll(REPLACE); System.out.println(INPUT); } }To replace only the first occurrence of the pattern, simply callOUTPUT: -foo-foo-foo-replaceFirst
instead ofreplaceAll
. It accepts the same parameter.Using
appendReplacement(StringBuffer,String)
andappendTail(StringBuffer)
The
Matcher
class also providesappendReplacement
andappendTail
methods for text replacement. The following example,RegexDemo.java
, uses these two methods to achieve the same effect asreplaceAll
.import java.util.regex.Pattern; import java.util.regex.Matcher; public class RegexDemo { private static String REGEX = "a*b"; private static String INPUT = "aabfooaabfooabfoob"; private static String REPLACE = "-"; public static void main(String[] args) { Pattern p = Pattern.compile(REGEX); Matcher m = p.matcher(INPUT); // get a matcher object StringBuffer sb = new StringBuffer(); while(m.find()){ m.appendReplacement(sb,REPLACE); } m.appendTail(sb); System.out.println(sb.toString()); } }OUTPUT: -foo-foo-foo-Matcher Method Equivalents in
For convenience, thejava.lang.String
String
class mimics a couple ofMatcher
methods as well:
public String replaceFirst(String regex, String replacement)
: Replaces the first substring of this string that matches the given regular expression with the given replacement. An invocation of this method of the formstr.replaceFirst(regex, repl)
yields exactly the same result as the expressionPattern.compile(regex).matcher(str).replaceFirst(repl)
public String replaceAll(String regex, String replacement)
: Replaces each substring of this string that matches the given regular expression with the given replacement. An invocation of this method of the formstr.replaceAll(regex, repl)
yields exactly the same result as the expressionPattern.compile(regex).matcher(str).replaceAll(repl)