Java Regular Expressions

Java offers the java.util.regex package for prototype matching with usual expressions. Java's usual expressions are extremely alike to the Perl programming language and incredibly trouble-free to learn.

A regular expression is an extraordinary series of characters that helps you bout or finds other strings or sets of strings, utilizing a specialized syntax detained in a pattern. They can be employed to hunt, edit, or influence text and data.

The java.util.regex package mainly comprises of the subsequent three classes −

• Pattern Class − A model entity is a compiled depiction of a normal expression. The Pattern class supplies no public constructors. To generate a prototype, you ought to first appeal to one of its community static compile() methods, which will then go back and outline the object. These techniques recognize a regular expression as the primary argument.
• Matcher Class − A Matcher class is the engine that understands the prototype and does match process alongside an effort string. Like the outline class, Matcher describes no public constructors. You get hold of a Matcher object by appealing to the matcher() method on a Pattern object.
• PatternSyntaxException − A PatternSyntaxException entity is an unchecked exception that points to a syntax error in a regular expression prototype.

Capturing Groups

Capturing groups are a technique to indulge multiple dispositions as a solitary unit. They are generated by placing the quality to be grouped surrounded by a set of parentheses. For instance, the regular expression (dog) creates a particular group having 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 discover out how numerous groups are here in the look, call the groupCount process on a matcher object. The groupCount method revisits an int viewing the number of capturing groups near in the matcher's outline.

There is also a particular group, group 0, which always symbolizes the complete expression. This group is not comprised in the total accounted by groupCount.

Example

The 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

Regular Expression Syntax

Here is the table listing down all the regular expression metacharacter syntax available in Java −

Methods of the Matcher Class

Here is a list of useful instance methods −

Index Methods

Index methods provide useful index values that show precisely where the match was found in the input string −

Study Methods

Study methods review the input string and return a Boolean indicating whether or not the pattern is found −

Replacement Methods

Replacement methods are useful methods for replacing text in an input string −

The start and end Methods

Following is the example that counts the number of times the word "cat" appears in the input string −

Example

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

This will produce the following result

Output

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 could observe that thees instance utilizations word boundaries to make sure that the letters "c" "a" "t" is not just a substring in a longer word. It also provides some helpful information concerning wherein the input string the match has occurred.

The create method revisits the create index of the subsequence detained by the given group through the preceding match procedure, and the end arrivals the index of the previous character matched, plus one.

The matches and lookingAt Methods

The matches and searching at methods together attempt to compete for an input progression against an outline. The disparity, however, is that matches necessitate the entire input succession to be matched while looking at does not.

Both techniques always create at the commencing of the input filament. Here is the illustration explaining the process −

Example

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

This will produce the following result:

Output

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

The replaceFirst and replaceAll Methods

The replaceFirst and replaceAll methods replace the text that matches a given regular expression. As their names indicate, replaceFirst replaces the first occurrence, and replaceAll replaces all occurrences.

Here is the example explaining the functionality −

Example

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

This will produce the following result:

Output

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

This will produce the following result:

Output

-foo-foo-foo-

PatternSyntaxException Class Methods

A PatternSyntaxException has ensured the exception that designates a syntax error in a usual expression prototype. The PatternSyntaxException class offers the subsequent methods to assist you settle on what went wrong

Here at Intellinuts, we have created a complete Java tutorial for Beginners to get started in Java.