Java Regular Expressions

Regular expressions are used for defining String patterns that can be used for searching, manipulating and editing a text. These expressions are also known as Regex (short form of Regular expressions).

Lets take an example to understand it better :

In the below example, the regular expression .*Java.* is used for searching the occurrence of String "Java" in the text.

import java.util.regex.*;

public class RegexExample1{

    public static void main(String[] args){
    
        String content = "Let's get started with Java Regular Expressions on SoloLearn";
        
        String pattern = ".*Java.*";
       
        boolean isMatch = Pattern.matches(pattern, content);
        
        System.out.println("The text contains 'Java'? "+ isMatch);
    }
}

// Output:
// The text contains 'Java'? true

In this tutorial we will learn how to define patterns and how to use them. The java.util.regex API (the package which we need to import while dealing with Regex ) has two main classes :

► java.util.regex.Pattern Used for defining patterns

► java.util.regex.Matcher Used for performing match operations on text using patterns

`java.util.regex.Pattern` Class

#1 `Pattern.matches()`

We have already seen the usage of this method in the above example where we performed the search for string "Java" in a given text. This is one of simplest and easiest way of searching a String in a text using Regex.

String content = "This is a tutorial with example!";
String patternString = ".*tutorial.*";

boolean isMatch = Pattern.matches(patternString, content); 

System.out.println("The text contains 'tutorial'? "+ isMatch);

As you can see we have used matches() method of Pattern class to search the pattern in the given text. The pattern .*tutorial.* allows zero or more characters at the beginning and end of the String "tutorial" (the expression .* is used for zero and more characters).

Limitations : This way we can search a single occurrence of a pattern in a text. For matching multiple occurrences you should use the Pattern.compile() method (discussed in the next section).

#2 `Pattern.compile()`

In the above example we searched a string "tutorial" in the text, that is a case sensitive search, however if you want todo a CASE INSENSITIVE search or want to do search multiple occurrences then you mayneed to first compile the pattern using Pattern.compile() before searching it in text. This is how this method can be usedfor this case.

String content == "This is a tutorial with example!";
String patternString = ".*tuToRiAl.";

Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);

Here we have used a flag Pattern.CASE_INSENSITIVE for case insensitive search, there are several other flags that can be used for different-2 purposes. To read more about such flags refer this document .

Now what : We have obtained a Pattern instance but how to match it? For that we would be needing a Matcher instance, which we can get using Pattern.matcher() method. Lets discuss it.

#3 `Pattern.matcher()` method

In the above section we learnt how to get a Pattern instance using compile() method. Here we will learn How to get Matcher instance from Pattern instance by using matcher() method.

String content = "This is a tutorial with example!";
String patternString = ".*tuToRiAl.*";

Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(content);

boolean isMatched = matcher.matches();

System.out.println("Is it a Match? "+ isMatched);

// Output:
// Is it a Match? true

#4 `Pattern.split()`

To split a text into multiple strings based on a delimiter (Here delimiter would be specified using Regex ), we can use Pattern.split() method. This is how it can be done.

import java.util.regex.*;

public class RegexExample2{

    public static void main(String[] args){
    
        String text = "ThisIsSololearn.ItISMyWebsite"; // Pattern for delimiter 
        String patternString = "is";
        
        Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
        
        String[] myStrings = pattern.split(text);
        
        for (String temp : myStrings){
            System.out.println(temp);
        }
        
        System.out.println("Number of split strings: "+ myStrings.length);
    }
}

// Output:
/*
Th Sololearn.


It MyWebsite
Number of split strings: 4
*/

The second split String is null in the output.

`java.util.regex.Matcher` Class

We already discussed little bit about Matcher class above. Lets recall few things:

Creating a Matcher instance

String content = "Some text";
String patternString = ".*somestring.*";

Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(content);

Main methods

matches() : It matches the regular expression against the whole text passed to the Pattern.matcher() method while creating Matcher instance.

Matcher matcher = pattern.matcher(content);
 
boolean isMatch = matcher.matches();

lookingAt() : Similar to matches() method except that it matches the regular expression only against the beginning of the text, while matches() search in the whole text.

find() : Searches the occurrences of of the regular expressions in the text. Mainly used when we are searching for multiple occurrences.

start() and end() : Both these methods are generally used along with the find() method. They are used for getting the start and end indexes of a match that is being found using find() method.

Lets take an example to find out the multiple occurrences using Matcher methods:

import java.util.regex.*;

public class RegexExampleMatcher{

    public static void main(String[] args){
    
        String content = "ZZZ AA PP AA QQQ AAA ZZ";
        String str = "AA";
        
        Pattern pattern = Pattern.compile(string);
        Matcher matcher = pattern.matcher(content);
        
        while (matcher.find()){
            System.out.println("Found at: "+ matcher.start() +" - "+ matcher.end());
        }
    }
}

// Output:
// Found at: 4 - 6
// Found at: 10 - 12
// Found at: 17 - 19

[JavaRegEx:] Tutorial with examples