Regular Expressions in Java

The Methods of the Pattern Class

The following table summarizes the methods that are specific to the Pattern class. Methods inherited from the Object class are not described here.

Method	Description
compile()	This static method compiles a regular expression pattern into a Pattern
	object.
flags()	Returns the flags set on a Pattern object.
matcher()	Creates a Matcher object that will match a regular expression against the
	test string.
matches()	This static method attempts to match a regular expression against a test
	string.
pattern()	Returns the regular expression pattern from which the Pattern object was
	compiled.
split()	Splits the test string at each occurrence of a match for a regular expression.

The compile() Method

There are two forms of the compile() method, each of which is static. One form takes a single argument, a String value containing a regular expression pattern. Any metacharacters, such as \d, must be written as \\d. The method throws a PatternSyntaxException.

The second form takes two arguments. The first argument is a String value containing a regular expression pattern. Any metacharacters, such as \d, must be written as \\d. The second argument is an int value indicating which flags are set. The method throws a PatternSyntaxException. if the regular expression is invalid and an IllegalArgumentException if the int value does not correspond to a permitted combination of flags.

The flags() Method

The flags() method takes no argument. It returns an int value corresponding to the flags (if any) that were set when the Pattern object was compiled.

The matcher() Method

The matcher() method takes one argument, a CharSequence value, which is the test string. A new Matcher object is returned that will match the CharSequence argument against the regular expression pattern specified for the Pattern object.

The matches() Method

This static method takes two arguments. The first argument is a String value containing the regular expression pattern. The second argument is a CharSequence value containing the test string. The matches() method returns a boolean value indicating whether or not matching was successful. The matches() method throws a PatternSyntaxException.

633

Chapter 25

The pattern() Method

The pattern() method takes no argument and returns a String value containing the regular expression pattern that was used to compile the Pattern object.

The split() Method

The split() method can take two forms. The first form has a single CharSequence value as its argument, which contains the test string. A String[] is returned. The CharSequence is split at each occurrence of the regular expression pattern. If the regular expression pattern matches the final character(s) in the CharSequence, the empty string following the match is not returned as part of the string array.

The second form behaves like the first except that it has an int value as its second argument. The int value specifies the maximum number of times that the CharSequence value may be split.

The Matcher Class

The Matcher class is where most of the work is done. The Matcher object interprets the regular expression and performs the matching operations.

The Matcher class provides no public constructor. To create a Matcher object, you must call the public matcher() method on a Pattern object (as shown earlier):

Matcher myMatcher = myPattern.matcher(“someString”);

The matcher() method takes a single argument, a string.

The methods of the Matcher class are summarized in the following table.

Method	Description
appendReplacement()	Appends a replacement string to a string buffer when a match is
	found.
appendTail()	Appends the remaining character sequence to a string buffer after
	the final match is found (or the whole character sequence, if no
	match is found).
end()	Returns the index (plus one) of the last character matched.
find()	Attempts to find a substring of the test string that matches the
	regular expression pattern.
group()	Used with no argument, it returns the matching substring. Used
	with one argument, it returns the matching substring for a speci-
	fied capturing group.
groupCount()	Returns the number of capturing groups in a regular expression
	pattern.
lookingAt()	Attempts to find a match for the regular expression pattern in the
	test string.

634

		Regular Expressions in Java
	Method	Description
	matches()	Attempts to match the whole test string against the regular
		expression pattern.
	pattern()	Returns the Pattern object used in matching.
	replaceAll()	Returns a string in which all occurrences of a regular expression
		pattern have been replaced by a replacement string.
	replaceFirst()	Returns a string in which the first occurrence of a regular expres-
		sion pattern has been replaced by a replacement string.
	reset()	Resets a Matcher object.
	start()	Returns the index of the first character in a match.

The appendReplacement() Method

The appendReplacement() method is intended for use with the find() and appendTail() methods. The following example uses the appendReplacement(), find(), and appendTail() methods together with a StringBuffer object to replace occurrences of the character sequence Star with the character sequence Moon.

Try It Out

The appendReplacement() Method

1.Type the following code in a text editor:

import java.io.*;

import java.util.regex.*;

public final class MatcherMethods { private static String myRegex; private static String testString;

private static BufferedReader myBufferedReader; private static Pattern myPattern;

private static Matcher myMatcher;

public static void main(String[] argv) { initResources();

processTest(); closeResources(); }

private static void initResources() { try {

myBufferedReader = new BufferedReader(new FileReader(“MatcherMethods.txt”));

}

catch (FileNotFoundException fnfe) {

System.out.println(“Cannot locate input file! “+fnfe.getMessage()); System.exit(0); }

try { myRegex = myBufferedReader.readLine(); testString = myBufferedReader.readLine();

}

catch (IOException ioe) {}

635

Chapter 25

myPattern = Pattern.compile(myRegex); myMatcher = myPattern.matcher(testString);

System.out.println(“Current myRegex is: “+myRegex); System.out.println(“Current testString is: “+testString);

}

private static void processTest()

{

StringBuffer myStringBuffer = new StringBuffer(); while (myMatcher.find())

{

myMatcher.appendReplacement(myStringBuffer, “Moon”);

} // end while loop myMatcher.appendTail(myStringBuffer); System.out.println(); System.out.println(myStringBuffer.toString());

}

private static void closeResources()

{

try{ myBufferedReader.close(); }catch(IOException ioe){}

}

}

2.Save the code as MatcherMethods.java; compile it; and at the command line, type javac MatcherMethods.java.

3.Type the following text in a text editor:

Star

Star Training Company is well known for high quality training. Star Training is currently offering special value training packages.

The preceding information other than the first word is all on one line in the file MatcherMethods.txt. It is shown wrapped on two lines for the convenience of printing.

4.Save the text as MatcherMethods.txt.

5.Run the Java code. At the command line, type java MatcherMethods, and inspect the results, as shown in Figure 25-5. Notice that each occurrence of the character sequence Star in the test string has been replaced by the character sequence Moon.

Figure 25-5

636

Regular Expressions in Java

How It Works

The key part of this example, as far as the Matcher object’s methods are concerned, is the use of the appendReplacement(), find(), and appendTail() methods.

A BufferedReader is used to accept the contents of MatcherMethods.txt:

myBufferedReader = new BufferedReader(new FileReader(“MatcherMethods.txt”));

The code in the processTest() method uses the appendReplacment(), find(), and appendTail() methods.

A myStringBuffer object is declared and instantiated as a new StringBuffer object:

StringBuffer myStringBuffer = new StringBuffer();

A while loop is used to progress through the test string. If a match is found, the myMatcher.find() method returns the boolean value of true, so the code in the while loop is executed:

while (myMatcher.find())

{

The appendReplacement() method progresses through the test character sequence, adding characters to the StringBuffer. If a match is found, the characters constituting the match are not added to the StringBuffer. Instead, the replacement text is appended to the string buffer. Matching continues in the test character sequence from a position immediately after the character sequence that was a match:

myMatcher.appendReplacement(myStringBuffer, “Moon”);

When no further matches are found, the while loop is exited:

} // end while loop

At this point, the string buffer contains the characters from the test character sequence up to the last match. The appendTail() method is used to append the remaining, nonmatching characters from the test character sequence to the StringBuffer:

myMatcher.appendTail(myStringBuffer);

A blank line is displayed to separate the test character sequence from the character sequence containing the replaced character sequence (assuming that a match was found). If there was no match, the original test character sequence and the “replaced” character sequence contain the same sequences of characters:

System.out.println();

The myStringBuffer object’s toString() method is used to allow the replaced string to be displayed using the println() method:

System.out.println(myStringBuffer.toString());

637