Java Regular Expressions

Java Regular Expressions

The Java language delivers the java.util.regex package that is basically for the pattern matching with the regular expressions. The Java regular expressions are extremely easy to learn and in functionalities and other things it is known to be very similar to the Perl programming language. A regular expression in java is basically a special sequence of the characters that assists the programmer in matching or finding other strings or sets of strings just by the use of a specialized syntax that is held in a pattern. These expressions can be used to search, edit, or manipulate the text and the data.

The java.util.regex package consists of three primarily classes that are depicted below along with a brief introduction:

• Pattern Class − A compiled representation of a regular expression is known as a pattern object. Since the pattern class does not delivers any public constructors hence, in order to create a pattern the programmer needs to first invoke one of the public static compile() methods of this functions and then they will return a Pattern object.
• Matcher Class − The engine that interprets the pattern and performs match operations against an input string is known as a matcher object. It is very similar to the Pattern class as it also defines no public constructors. The programmer have to obtain a matcher object just by invoking the matcher() method that too on a Pattern object.
• PatternSyntaxException − An unchecked exception that usually indicates a syntax error in the regular expression pattern in java is known as a PatternSyntaxException object.

Capturing Groups

The method of treating multiple characters as a single unit is known as capturing groups. These groups are generally created by placing the characters that are to be grouped inside a set of the parentheses. For instance, the regular expression (god) creates a single group containing the letters "g", "o", and "d". Capturing groups are generally numbered just by counting their opening parentheses from the direction left to the right. For another instance, in the expression ((D)(E(F))), for example, there are four such groups that are depicted below:

• ((D)(E(F)))
• (D)
• (E(F))
• (F)

Now, in order to find out that how many groups are present there in the expression the programmer should call the groupCount method on a matcher object. The groupCount method is known to return an int that displays the number of capturing groups that present there in the matcher's pattern. In order to represent the entire expression there is a special group that is called group 0. Please note that this group is generally not included in the total groups that are reported by groupCount.

Here is an example that will demonstrates how to find a digit string from the provided alphanumeric string in Java. Please have a thorough look at it:

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

Regular Expression Syntax

Here is the table that is listing down all the regular expression metacharacter syntax that are available in Java:

Methods of the Matcher Class

Here is a list of all the useful instance methods that are used in Java:

1. Index Methods

Index methods in java generally deliver useful index values that display precisely where the match was found in the input string:

2. Study Methods

Study methods in the Java generally review the input string and it returns a Boolean that indicates whether the pattern is found or not:

3. Replacement Methods

Replacement methods in java are generally proven to be useful in methods for replacing text in an input string:

The start and end Methods

Here is an example that will count the number of times the word "dog" appears in the input string, please have a look at it:

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

public class  RegexMatches {

   private static final String REGEX = "\\bPHP\\b";
   private static final String INPUT = "PHP PHP PHPTPOINT PHP Python PHP";

   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());
      }
   }
}

The Matches And Lookingat Methods

The matches and lookingAt methods both generally used to match an input sequence that is against a pattern. The difference in these two is that the matches basically require the entire input sequence to be matched, on the other hand the while lookingAt does not.

Here is the example of both these methods that will explain the functionality:

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

public class RegexMatches {

   private static final String REGEX = "PHP";
   private static final String INPUT = "PHPTPOINT";
   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 replaceFirst and replaceAll Methods

The replaceFirst and replaceAll methods in java are used to replace the text that generally matches a provided regular expression. As per their names, replaceFirst is used to replace the first occurrence on the other hand replaceAll is used to replaces all the occurrences.

Here is the example that will explain the functionality of both the methods:

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

public class RegexMatches {

   private static String REGEX = "Python";
   private static String INPUT = "Python is the best language. " + "I love Python.";
   private static String REPLACE = "Java";

   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 appendReplacement and appendTail Methods

In order to perform the text replacement, the Matcher class is also known to provide appendReplacement and appendTail methods.

Here is the example of both of these methods that will explain the functionality:

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

public class RegexMatches {

   private static String REGEX = "a*b";
   private static String INPUT = "aabJerryaaabJerryabJerrybb";
   private static String REPLACE = "*";
   public static void main(String[] args) {

      Pattern p = Pattern.compile(REGEX);
      
      // get a 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());
   }
}

PatternSyntaxException Class Methods

An unchecked exception that generally indicates a syntax error in a regular expression pattern is known as a PatternSyntaxException in Java. The PatternSyntaxException class is also known to deliver the following depicted methods that will help you in determining the exact error in the case the things went wrong: