Java Tutorial Blog

What is Regular Expression in Java

//  by 

Regular Expressions or Regex can be described as a sequence of characters used for searching the specified data using a particular pattern. When you search for specific data you may define the pattern to search that particular string. These patterns are used to search for strings like email, password, and addresses. The Regular expressions are quite helpful in performing the operations related to searching the text and replacing it.

In this article, we will elaborate on the insights of Regex in Java. 

What is Regular Expression in Java?

The regular expression in Java is used in defining a certain pattern of searching the items. When there is a need to search for any data this searching pattern is implemented. In Java, there is no built-in method present to search for the elements therefore, the package java.util.regex is used to work with these expressions. This package comprises three classes and one interface. These are listed below.

  • Pattern Class in Java
  • Matcher Class of Regex in Java
  • PatternSyntaxException Class in Java
  • MatchResult Interface of Regex in Java

Pattern Class

The pattern class is imported using the “java.util.regex” package. The pattern and the matcher class work in parallel. The pattern to be checked is declared using the pattern class and the pattern is matched using the Matcher class. The code below depicts the implementation of the pattern class in Java.

//Import the required regex packages
import java.util.regex.*;
class PatternClass {
public static void main(String[] args)
{
Pattern p = Pattern.compile("HelloinJava");
Matcher m = p.matcher("Print the statement HelloinJava");
System.out.println("Checking if the pattern exists");
//Using the find() method to search for the pattern
if (m.find())
System.out.println("The pattern is found");
else
System.out.println("The pattern is not found");
}
}

In the above code:

  • The “regex.pattern” package is imported in Java.
  • A class is declared as “PatternClass”.
  • A pattern “p” is declared using the compile() method.
  • The matcher() method is declared as the “m” that matches the pattern from the declared pattern.
  • The if-else statement prints the output as the result is found or not.

Output

The below output depicts that the pattern “HelloinJava” matches with the declared text “Print the statementHelloinJava”.

Matcher Class

The Matcher class of Java is implemented using the MatchResult Interface in Java. The matcher() method checks if the declared pattern in the pattern() method matches with the declared pattern. The code below implements the Matcher class of regex.

//Import the Matcher and the Pattern packages
import java.util.regex.Matcher;
import java.util.regex.Pattern;
//Declare the matcherclass
class Matcherclass {
public static void main(String args[])
{
    //Declare a new pattern
Pattern p = Pattern.compile("Java");
        //Now, search the below pattern in above
Matcher matc = p.matcher("Programming in Java");
while (matc.find())
//Declare the starting and the ending index to get the pattern
System.out.println("The Pattern is found from "
+ matc.start() + " to "
+ (matc.end() - 1));
}
}

In the above code:

  • The Matcher and Pattern packages are imported.
  • In the Main class a pattern “p” is declared with the compile() method.
  • The matcher method matches the pattern with the specified string.
  • The println() method prints the index of the matching pattern from start to end.

Output

The below output depicts that the string “Java” is present from index 15 to 19, since the end values are 1 less the results become 15 to 18.

PatternSyntaxException Class

For any syntax in pattern matching, Java provides a class known as the PatternSyntaxException Class. Below is the code and the syntax of the PatternSyntax exception in Java.

PatternSyntaxException(String description, String regex, int index)

In the syntax above, the description of the specified string, the regex, and the integer value are the three parameters of the pattern exception class.

//Import the required package
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
//Declare the class for patternsyntax exception
public class Patternexception {
private static String REG = "?[^x-tA-Z0-8]";
private static String Messg= "Learn/ java? with us!!";
private static String REPLACE = " ";
//Main class of Java
public static void main(String[] args)
{
try {
//The pattern method
Pattern pattern = Pattern.compile(REG);
// The matcher object
Matcher matcher = pattern.matcher(Messg);
// Replace the string
Messg = matcher.replaceAll(REPLACE);
// catch block for handling PatternSyntaxException.
}
catch (PatternSyntaxException e) {
System.out.println("PatternSyntaxException: ");
System.out.println("Description: "+ e.getDescription());
System.out.println("The Index is : " + e.getIndex());
System.out.println("The Message is : "+ e.getMessage());
System.out.println("The Pattern is : "+ e.getPattern());
System.exit(0);
}
System.out.println("Output: " + Messg);
}
}

In the above Java code:

  • The required packages are imported.
  • In the next step, a class is declared as PatternException.
  • The first string is declared as REG, the second consists of a message declared as “Messg” and the third contains the replaceAll() method for the alphanumeric character to be replaced with space.
  • The try block contains the pattern, matcher, and replace methods.
  • The catch block consists of the three parameters declared in the syntax of the patternException class.

Output

The below output, shows that the ? is the cause for trouble since whenever we are working with the meta characters we should be careful and use the escape characters instead.

MatchResult Interface

The match result interface in Java is responsible for matching the results. It implements the query method to determine the results obtained from the match group against the regular expressions of Java. the interface method consists of abstract methods. It may or may not consist of variables. Since Java accepts multiple inheritances through different interfaces, therefore, there is a wide scope of interfaces. 

This sums up the topic of Regex in Java.

Conclusion

The Regular Expression or Regex in Java is responsible for manipulating, searching, and editing the strings in Java. In Java, built-in classes like Pattern Class, Matcher Class, and PatternSyntaxException Class are used to implement regular expressions. The MatchResult Interface can also be used to do the same functionality. In this article, we have implemented the three classes and one interface of Regular Expression in Java.