How to use Regular Expression in Java – Tutorial and Importance

What is Regular Expression in Java

A Regular Expression or regEx in Java is a special string of characters that helps you match or find other strings or sets of strings by using a special syntax held in a pattern.

They can be used to find text and data, change it, or do other things with it.

Does Java have Regular Expressions?

Java doesn’t have a built-in Regular Expression class, but we can work with them by importing the java.util.regex package.

Two Types of Regular Expression

There are two types of Regular Expression In Programming.

• Basic regular expression
• Extended regular expression

What are the Applications of Regular Expressions in Java?

The Regular Expressions In Java can be used for all kinds of text search and text replace operations.

Java doesn’t have a built-in Regular Expression class, but we can work with them by importing the java.util.regex package.

Importance of Regular Expression in Java

The Regular Expression In Java is a very important tool for finding patterns and making sure that forms are correct.

Look at its Properties, how it can be used, and what it can’t do.

Without further ado, I will further explain the Regular Expression In Java with some basic examples in order for you to easily understand the topic.

The java.util.regex package in Java lets you use regular expressions to match patterns.

Java Regular Expressions are very easy to learn and are very similar to the programming language Perl.

Perl is an open-source, cross-platform programming language that is used a lot in both business and personal computing.

In the late 20th century and early 21st century, Perl was a favorite among Web developers because it could process text in many different ways and solve problems in many different ways.

Description Of java.util.regex.package

The java.util.regex.package is a class that uses regular expressions to match character sequences to patterns.

The java.util.regex package is primarily made up of the following three classes listed in the table below:

Capturing Groups In Java

The Capturing Groups In Java are a way to treat several characters as a single unit.

They are made by putting the characters to be grouped inside a set of parentheses.

For example, the regular expression (dog) creates a single group with the letters “d”, “o”, and “g”.

Capturing Groups In Java are numbered by counting the opening parentheses from left to right.

In the expression ((A)(B(C))).

List of four examples of Capturing Groups In Java is listed below.

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

What is an Example Of Regular Expression in Java

The table below shows some examples of Regular Expressions In Java.

How Do You Find Out How Many Groups are in an Expression in Java,

To find out how many groups are in the expression, call the groupCount method on a matcher object.

The groupCount method returns an int that shows how many capturing groups are in the matcher’s pattern.

There is also a special group called group 0 that always represents the entire expression.

This group isn’t counted in the total given by groupCount.

Example Program in Java for Capturing Groups

The following example shows how to find a digit string in a given alphanumeric string.

// program created by Glenn 
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 PIES5G13000! 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");
      }
   }
}

Output:

Found value: This order was placed for PIES5G13000! OK?
Found value: This order was placed for PIES5G1300
Found value: 0

In order for you to test the Java code provided in this lesson, you must test the code in your code editor.

But if you wish to run this code online, we also have an online compiler in Java for you to test your Java code for free.

You can test the above example here! ➡Java Online Compiler 

Regular Expression Syntax In Java

Lists of the following Regular Expression Syntax In Java are in the table below.

Methods of The Matcher Class in Java

The following are useful instance methods of Matcher Class In Java.

Index Methods in Java

The Index Methods In Java give useful index values that show where in the input string the match was found.

The following is the list of index methods provided in the table below.

Study Methods in Java

A Study Methods In Java review the input string and give back a Boolean that says if the pattern was found or not.

The following is the list of study methods provided in the table below.

Replacement Methods In Java

The Replacement Methods In Java these are useful for replacing text in an input string.

The following is the list of replacement methods provided in the table below.

Start and End Methods In Java

Here is an example that counts the number of times the word “horse” appears in the input string.

Example:

// program by Glenn
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "\\bhorse\\b";
   private static final String INPUT = "horse horse horse horsie horrse";

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

Output:

Match number 1
start(): 0
end(): 5
Match number 2
start(): 6
end(): 11
Match number 3
start(): 12
end(): 17

You can test the above example here! ➡Java Online Compiler 

You can see that this example uses word boundaries to make sure that the letters “h” “o” “r” “s” “e” are not just parts of a longer word.

It also tells you where in the input string the match happened, which is helpful.

The start method returns the start index of the subsequence captured by the given group in the previous match operation.

The end method returns the index of the last character matched, plus one.

Matches and lookingAt Methods in Java

The matches and lookingAt methods both try to match an input sequence with a pattern.

The difference is that matches need the entire input sequence to be matched, while lookingAt does not.

Both methods always start from the beginning of the input string. Here is an example that shows how it works:

Example:

// program created bY Glenn
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "Goo";
   private static final String INPUT = "Gooooooooooooooooo";
   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());
   }
}

Output:

Current REGEX is: Goo
Current INPUT is: Gooooooooooooooooo
lookingAt(): true
matches(): false

replaceFirst and replaceAll methods in Java

The replaceFirst and replaceAll methods in Java change the text that matches a given regular expression.

As their names suggest, replaceFirst changes the first time a word appears, and replaceAll changes every time it appears.

The following are examples and explanations of the functionality.

Example:

// program by Glenn
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "horse";
   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);
   }
}

Output:

The dog says meow. All dogs say meow.

You can test the above example here! ➡Java Online Compiler 

appendReplacement and appendTail Methods In Java

The Matcher class also has the appendReplacement and appendTail methods in Java for replacing text.

• appendReplacement Method In Java – The append-and-replace step is done with this method. First, it replaces a compiled character or word with the given input sequence. Then, it adds the given replacement string to the string buffer.

• appendTail Method In Java – The appendTail(StringBuilder) method of the Matcher Class acts as an append-and-replace method. This method takes the input string and adds it to the given StringBuilder at the end. Parameters: This method takes as a parameter a StringBuilder that holds the target string.

The following are examples and explanations of the functionality.

Example:

// program by Glenn
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "a*c";
   private static String INPUT = "aacgooaacgooacgooc";
   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());
   }
}

Output:

-goo-goo-goo-

You can test the above example here! ➡Java Online Compiler 

PatternSyntaxException Class Methods in Java

A PatternSyntaxException in Java is an unchecked exception that happens when there is a syntax error in a regular expression pattern.

The PatternSyntaxException class offers the following ways to figure out what went wrong.

The following is a list of PatternSyntaxException In Java listed in the table below.

Conclusion

In conclusion, we have discussed the Regular Expressions (regex) in Java which are special strings used for finding and manipulating text patterns.

Java doesn’t have a built-in regex class, but it provides the java.util.regex package for this purpose.

Regular expressions are crucial for tasks like text search, replace operations, and form validation in Java.

We have covered the basics, types of regex, and their applications, and provided examples.

What’s Next

The next section talks about Methods In Java programming. At the end of the session, you’ll know what methods are all about in Java.

< PREVIOUS

Java Regular Expression

NEXT >

Java.io and Files