Java Regex - Quick Guide

Java Regex - Overview

Java provides the java.util.regex package for pattern matching with regular expressions. Java regular expressions are very similar to the Perl programming language and very easy to learn.

A regular expression is a special sequence of characters that helps you match or find other strings or sets of strings, using a specialized syntax held in a pattern. They can be used to search, edit, or manipulate text and data.

The java.util.regex package primarily consists of the following three classes −

• Pattern Class − A Pattern object is a compiled representation of a regular expression. The Pattern class provides no public constructors. To create a pattern, you must first invoke one of its public static compile() methods, which will then return a Pattern object. These methods accept a regular expression as the first argument.

• Matcher Class − A Matcher object is the engine that interprets the pattern and performs match operations against an input string. Like the Pattern class, Matcher defines no public constructors. You obtain a Matcher object by invoking the matcher() method on a Pattern object.

• PatternSyntaxException − A PatternSyntaxException object is an unchecked exception that indicates a syntax error in a regular expression pattern.

Java Regex - Capturing Groups

Capturing groups are a way to treat multiple characters as a single unit. They are created by placing the characters to be grouped inside a set of parentheses. For example, the regular expression (dog) creates a single group containing the letters "d", "o", and "g".

Capturing groups are numbered by counting their opening parentheses from the left to the right. In the expression ((A)(B(C))), for example, there are four such groups −

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

To find out how many groups are present in the expression, call the groupCount method on a matcher object. The groupCount method returns an int showing the number of capturing groups present in the matcher's pattern.

There is also a special group, group 0, which always represents the entire expression. This group is not included in the total reported by groupCount.

Example

Following example illustrates how to find a digit string from the given alphanumeric string −

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

public class RegexMatches {
   public static void main( String args[] ) {
      // String to be scanned to find the pattern.
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // Create a 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");
      }
   }
}

This will produce the following result −

Output

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

Java Regex - MatchResult Interface

Introduction

The java.util.regex.MatchResult interface represents the result of a match operation. This interface contains query methods used to determine the results of a match against a regular expression. The match boundaries, groups and group boundaries can be seen but not modified through a MatchResult.

Interface declaration

Following is the declaration for java.util.regex.MatchResult interface −

public interface MatchResult

Interface methods

Java Regex - Pattern Class

Introduction

The java.util.regex.Pattern class represents a compiled representation of a regular expression.

Class declaration

Following is the declaration for java.util.regex.Pattern class −

public final class Pattern
   extends Object
      implements Serializable

Field

Following are the fields for java.util.regex.Duration class −

• static int CANON_EQ − Enables canonical equivalence.

• static int CASE_INSENSITIVE − Enables case-insensitive matching.

• static int COMMENTS − Permits whitespace and comments in pattern.

• static int DOTALL − Enables dotall mode.

• static int LITERAL − Enables literal parsing of the pattern.

• static int MULTILINE − Enables multiline mode.

• static int UNICODE_CASE − Enables Unicode-aware case folding.

• static int UNICODE_CHARACTER_CLASS − Enables the Unicode version of Predefined character classes and POSIX character classes.

• static int UNIX_LINES − Enables Unix lines mode.

Class methods

Methods inherited

This class inherits methods from the following classes −

• Java.lang.Object

Java Regex - Matcher Class

Introduction

The java.util.regex.Matcher class acts as an engine that performs match operations on a character sequence by interpreting a Pattern.

Class declaration

Following is the declaration for java.util.regex.Matcher class −

public final class Matcher
   extends Object
      implements MatchResult

Class methods

Methods inherited

This class inherits methods from the following classes −

• Java.lang.Object

Java Regex - PatternSyntaxException Class

Introduction

The java.util.regex.PatternSyntaxException class represents a unchecked exception thrown to indicate a syntax error in a regular-expression pattern.

Class declaration

Following is the declaration for java.util.regex.PatternSyntaxException class −

public class PatternSyntaxException
   extends IllegalArgumentException

Constructors

Class methods

Methods inherited

This class inherits methods from the following classes −

• Java.lang.Throwable
• Java.lang.Object

Example

The following example shows the usage of java.util.regex.Pattern.PatternSyntaxException class methods.

package com.howcodex;

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

public class PatternSyntaxExceptionDemo {
   private static String REGEX = "[";
   private static String INPUT = "The dog says meow " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      try{
         Pattern pattern = Pattern.compile(REGEX);
         
         // get a matcher object
         Matcher matcher = pattern.matcher(INPUT); 
         INPUT = matcher.replaceAll(REPLACE);
      } catch(PatternSyntaxException e){
         System.out.println("PatternSyntaxException: ");
         System.out.println("Description: "+ e.getDescription());
         System.out.println("Index: "+ e.getIndex());
         System.out.println("Message: "+ e.getMessage());
         System.out.println("Pattern: "+ e.getPattern());
      }
   }
}

Let us compile and run the above program, this will produce the following result −

PatternSyntaxException: 
Description: Unclosed character class
Index: 0
Message: Unclosed character class near index 0
[
^
Pattern: [

Java Regex - Examples Matching Characters

Following are various examples of matching characters using regular expression in java.

Java Regex - Matching Character Classes

Following are various examples of matching character classes using regular expression in java.

Matching Predefined Character Classes

Following are various examples of matching predefined character classes using regular expression in java.

Matching POSIX Character Classes

Following are various examples of matching POSIX character classes using regular expression in java.

Matching JAVA Character Classes

Following are various examples of matching JAVA character classes using regular expression in java.

Matching Unicode Character Classes

Following are various examples of matching Unicode character classes using regular expression in java.

Examples of Boundary Matchers

Following are various examples of Boundary Matchers using regular expression in java.

Java Regexs of Greedy Quantifiers

A greedy quantifier indicates to search engine to search the entire string and check whether it matches the given regexp. Following are various examples of Greedy Quantifiers using regular expression in java.

Examples of Reluctant Quantifiers

A reluctant quantifier indicates the search engine to start with the shortest possible piece of the string. Once match found, the engine continue; otherwise it adds one character to the section of the string being checked and search that, and so on. This process follows until it finds a match or the entire string has been used up. Following are various examples of Reluctant Quantifiers using regular expression in java.

Examples of Possessive Quantifiers

A possessive quantifier is similar to greedy quantifier. It indicates the engine to start by checking the entire string.It is different in the sense if it doesn't work, if match failed and there is no looking back. Following are various examples of Possessive Quantifiers using regular expression in java.

Java Regex - Examples of Logical Operators

Following are various examples of Logical Operators using regular expression in java.