Java regular expressions

Regular expressions define patterns of strings.

Regular expressions can be used to search, edit or manipulate text.

Regular expressions are not limited to one language, but there are subtle differences in each language.

Java regular expressions are most similar to Perl's.

The java.util.regex package mainly includes the following three classes:

• Pattern class:

  The pattern object is a compiled representation of a regular expression. Pattern class has no public constructor. To create a Pattern object, you must first call its public static compile method, which returns a Pattern object. This method accepts a regular expression as its first parameter.

• Matcher class:

  The Matcher object is an engine that interprets and matches input strings. Like the Pattern class, Matcher has no public constructor. You need to call the matcher method of the Pattern object to obtain a Matcher object.

• PatternSyntaxException:

  PatternSyntaxException is a non-mandatory exception class that represents a syntax error in a regular expression pattern.

Capturing group

Capturing groups are a way to treat multiple characters as a single unit, created by grouping characters within parentheses.

For example, the regular expression (dog) creates a single group containing "d", "o", and "g".

Capturing groups are numbered by counting their opening brackets from left to right. For example, in the expression ((A)(B(C))), there are four such groups:

• ((A)(B(C)))

• (A)

• (B(C))

• (C)

You can check how many groups an expression has by calling the groupCount method of the matcher object. The groupCount method returns an int value, indicating that the matcher object currently has multiple capturing groups.

There is also a special group (group 0) which always represents the entire expression. The group is not included in the return value of groupCount.

Example

The following example shows how to find a string of digits from a given string:

 import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
public static void main( String args[] ){

// Search the string according to the specified pattern String line = "This order was placed for QT3000! OK?";
String pattern = "(.*)(\d+)(.*)";

//Create Pattern object Pattern r = Pattern.compile(pattern);

// Now create matcher object Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println("Found value: " + m.group(0) );
System.out.println("Found value: " + m.group(1) );
System.out.println("Found value: " + m.group(2) );
} else {
System.out.println("NO MATCH");
}
}
}

The compilation and running results of the above example are as follows:

 Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

Regular expression syntax

Methods of Matcher class

Index method

The index method provides useful index values ​​that indicate exactly where in the input string the match is found:

research methods

The research method examines the input string and returns a Boolean value indicating whether the pattern was found:

replacement method

The replacement method is a method for replacing text in the input string:

start and end methods

Here is an example of counting the number of occurrences of the word "cat" in an input string:

 import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
private static final String REGEX = "\bcat\b";
private static final String INPUT =
"cat cat cat cattie cat";

public static void main( String args[] ){
Pattern p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // Get the 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());
}
}
}

The compilation and running results of the above example are as follows:

 Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

You can see that this example uses word boundaries to ensure that the letters "c" "a" "t" are not just a substring of a longer word. It also provides some useful information about where in the input string the match occurred.

The start method returns the initial index of the subsequence captured by the given group during the previous matching operation, and the end method adds one to the index of the last matched character.

matches and lookingAt methods

The matches and lookingAt methods are both used to try to match an input sequence pattern. The difference between them is that matches requires the entire sequence to match, while lookingAt does not.

These two methods are often used at the beginning of the input string.

We use the following example to explain this function:

 import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
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[] ){
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());
}
}

The compilation and running results of the above example are as follows:

 Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

replaceFirst and replaceAll methods

The replaceFirst and replaceAll methods are used to replace text that matches a regular expression. The difference is that replaceFirst replaces the first match and replaceAll replaces all matches.

The following example explains this functionality:

 import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
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);
//get a matcher object
Matcher m = p.matcher(INPUT);
INPUT = m.replaceAll(REPLACE);
System.out.println(INPUT);
}
}

The compilation and running results of the above example are as follows:

 The cat says meow. All cats say meow.

appendReplacement and appendTail methods

The Matcher class also provides appendReplacement and appendTail methods for text replacement:

Look at the following example to explain this functionality:

 import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
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);
// Get the matcher object Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}

The compilation and running results of the above example are as follows:

 -foo-foo-foo-

Methods of the PatternSyntaxException class

PatternSyntaxException is an unforced exception class that indicates a syntax error in a regular expression pattern.

The PatternSyntaxException class provides the following methods to help us see what errors occurred.