How to use Regex in Java

Introduction

In this article, we will learn about Java Regex and how to use Regex with examples in Java. Java regex is also known as Java Regular Expression.

What is Regex in Java?

Regular expressions or Java Regex is an API built to define string patterns that can be used to read, alter, and delete data. For pattern matching with the regular expressions, Java offers java.util.regex bundle.

In other words, a regular expression is a special sequence of characters that helps us match or find other strings using a special syntax held in a pattern that is used to search, edit, or manipulate text and data.

java.util.regex package

This provides regular expressions with three classes and a single interface. The classes Matcher and Pattern are usually used in standard Java language.

The complete program of the regex package is listed below.

import java.util.regex.Pattern;  
  
public class RegexPackageExample {  
    public static void main(String args[]) {  
        System.out.println(Pattern.matches(".y", "toy"));  
        System.out.println(Pattern.matches("s..", "sam"));  
        System.out.println(Pattern.matches(".a", "mia"));  
    }  
}

The above program generates the following output.

regex_package_example_output

PatternSyntaxException class

PatternSyntaxException is an unresolved exception object which means a syntax error in a normal speaking pattern.

The complete program of Showing the PatternSyntaxException class example is listed below.

import java.util.regex.Pattern;  
  
public class PatternSyntaxExceptionExample {  
    public static void main(String... args) {  
        String regex = "["; // invalid regex  
        Pattern pattern = Pattern.compile(regex);  
    }   
}

The above program generates the following output.

pattern_syntax_exception_output

Note. In the above example program, we use the invalid syntax of regex. So, when we run the program, it generates the PatternSyntaxException: Unclosed character class near index 0;

java.util.regex.Matcher;

A Matcher entity is a motor that interprets the template against an input string and executes operations of play. Matcher doesn't describe any public builders as the class Template. By calling the matcher method) (You get a Matcher object on a Pattern object.

Methods of Matcher class

public boolean matches()

The matches method is used to check whether the pattern string matches with the matcher string or not. It returns the boolean value. If the string matches, it returns true otherwise false. It does not take any argument. It does not throw any exception.

Syntax

public boolean matches();

The complete program of java.util.regex.Matcher.matches() method is listed below.

import java.util.regex.*;  
public class MatchesMethodExample {  
    public static void main(String[] args) {  
        boolean result;  
        // Get the string value to be checked  
        String value1 = "CsharpCorner";  
  
        // Create a pattern from regex  
        Pattern pattern = Pattern.compile(value1);  
  
        // Get the String value to be matched  
        String value2 = "CsharpC";  
  
        // Create a matcher for the input String  
        Matcher matcher = pattern.matcher(value2);  
  
        // Get the current matcher state  
        System.out.println("result : " + matcher.matches());  
    }  
}

The above program generates the following output.

matches_examplr_method_output

public int start() Method

The start() method is used to get the start subsequence index. public int start() method does not take any argument. It returns the index of the first character matched 0. If the operation fails, it throws IllegalStateException.

Syntax

public int start();

The complete program of java.util.regex.Matcher.start() method is listed below.

import java.util.regex.*;  
  
public class StartMethodExample {  
    public static void main(String[] args) {  
  
        // Get the string value to be checked  
        String value1  = "CsharpCorner";  
  
        // Create a pattern from regex  
        Pattern pattern = Pattern.compile(value1);  
  
        // Get the String value to be matched  
        String value2 = "Csharp";  
        // Create a matcher for the input String  
        Matcher matcher = pattern.matcher(value2);  
  
        // Get the current matcher state  
        MatchResult result = matcher.toMatchResult();  
        System.out.println("Current Matcher: " + result);  
  
        while (matcher.find()) {  
            // Get the first index of match result  
            System.out.println(matcher.start());  
        }  
    }  
}

The above program generates the following output.

Start_method_example_output

public boolean find() Method

The find method is used to find the next subsequence of the input sequence that finds the pattern. It returns a boolean value. If the input string matches, then it returns true otherwise returns false. This method does not take any argument. This method does not throw any exception.

Syntax

public boolean find()

The complete program of java.util.regex.Matcher.find() method is listed below.

import java.util.regex.*;  
public class FindMethodExample {  
    public static void main(String args[]) {  
        // Get the regex to be checked  
        String value = "CsharpCorner";  
        String value1 = "Java Programming";  
  
        // Create a string from regex  
        Pattern pattern = Pattern.compile(value);  
        Pattern pattern1 = Pattern.compile(value1);  
  
        // Get the String for matching  
        String matchString = "CsharpCorner";  
        String matchString1 ="Java";  
  
        // Create a matcher for the String  
        Matcher match = pattern.matcher(matchString);  
        Matcher match1 = pattern.matcher(matchString1);  
        //find() method  
        System.out.println(match.find());  
        System.out.println(match1.find());  
  
    }  
}

The above program generates the following output.

find_method_example_output

public boolean find(int start) Method

The find(int start) method is used to find the next subsequence of the input sequence that finds the pattern according to the given argument. It returns a boolean value. This method does not take any argument. This method throws IndexOutOfBoundException if the given argument is less than zero or greater than the length of the string.

Syntax

public boolean find(int start);

The complete program of java.util.regex.Matcher.find() method is listed below.

import java.util.regex.*;  
  
public class FindMethodExample2 {  
    public static void main(String args[]) {  
        // Get the regex to be checked  
        String value = "CsharpCorner";  
        String value1 = "Java Programming";  
  
        // Create a string from regex  
        Pattern pattern = Pattern.compile(value);  
        Pattern pattern1 = Pattern.compile(value1);  
  
        // Get the String for matching  
        String matchString = "CsharpCorner";  
        String matchString1 = "Java";  
  
        // Create a matcher for the String  
        Matcher match = pattern.matcher(matchString);  
        Matcher match1 = pattern.matcher(matchString1);  
        //find() method  
        System.out.println(match.find(3));  
        System.out.println(match1.find(6));  
  
    }  
}

The above program generates the following output.

find_example_method2_output

public int end() Method

The end method is used to get the offset after the last match of the character is done. This method doesn't take any argument. this method throws IllegalStateException if the operation fails.

Syntax

public int end()

The complete program example of java.util.regex.Matcher.end() is listed below.

import java.util.regex.*;  
public class endMethodExample {  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        Pattern p=Pattern.compile("Hello C#Corner");  
        Matcher m=p.matcher("Hello C#Corner");  
        if(m.matches())  
            System.out.println("Both are matching till "+m.end()+" character");  
        else  
            System.out.println("Both are not matching"+m.end());  
    }  
}

The above program generates the following output.

end_method_example_output

java.util.regex.Pattern

A Pattern object is a compiled representation of a regular expression. There are no Template-level public designers. To construct a template, you first need to invoke one of its public static compiles (methods that subsequently return a Template item, which acknowledges a regular expression as the first statement

It is the compiled form of a regular expression and is used to describe the Regex engine template.

Methods of Pattern Class

static Pattern compile(String regex)

The compile() method is used to match a text from a regular expression(regex) pattern. If the operation fails, it returns false otherwise true. This method takes a pattern string value as the argument.

Syntax

static Pattern compile(String regex)

The complete program of the java.util.regex.pattern.compile();

import java.util.regex.Matcher;  
import java.util.regex.Pattern;  
  
public class CompileMethodExample {  
  
    public static void main(String args[]) {  
  
        // Get the string value to be checked  
        Pattern p = Pattern.compile(".o");  
          
        //Matcher string for  
        Matcher m = p.matcher("to");  
        boolean m1 = m.matches();  
        System.out.println(m1);  
    }  
}

The above program generates the following output.

compile_method_example_output

public boolean matches(regex, String)

The matches() method is used to check whether the given string matches the given regular expression or not. This method returns the boolean value true if the string matches the regex otherwise, it returns false. If the syntax is invalid, then this method throws PatternStateException.

This method takes two arguments.

regex: This argument is the regular expression value that has to be checked from the string.
String: This string value has to be checked from the regex through the matches() method.

The complete program of the public boolean matches(regex, String) method is listed below.

import java.util.regex.Pattern;  
  
public class PatternClassMatchesMethod {  
    public static void main(String args[]) {  
        System.out.println(Pattern.matches("[bad]", "abcd"));  
        System.out.println(Pattern.matches("[as]", "a"));  
        System.out.println(Pattern.matches("[ass]", "asssna"));  
    }  
}

The above program generates the following output.

pattern_class_matches_method_output

Summary

In this article, we learned about Java Regular Expression(regex) in Java Programming Language and the various methods of regex.