How to Make Java Regular Expression Case Insensitive in Java?

In Java, regular expressions (regex) are powerful tools for pattern matching within strings. By default, Java's regex engine is case sensitive, meaning it distinguishes between uppercase and lowercase letters in patterns and input strings. However, there are methods and techniques to make Java regular expressions case insensitive when needed.

Using CASE_INSENSITIVE flag
Case Insensitivity with Complex Pattern
Case Insensitivity with Groups
Using Modifier

1. Using CASE_INSENSITIVE flag

Java provides a straightforward way to make regular expressions case insensitive by using the Pattern.CASE_INSENSITIVE flag with the compile method of the Pattern class. This flag allows the regex engine to ignore differences in letter case when matching patterns against input strings.

File Name: RegexExample.java

 
import java.util.regex.*;
public class RegexExample {
    public static void main(String[] args) {
        // Define the regular expression pattern
        String regex = "hello";
        // Input string to search for matches
        String input = "Hello, World!";
        // Compile the regular expression with CASE_INSENSITIVE flag
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        // Create a matcher object for the input string
        Matcher matcher = pattern.matcher(input);
        // Perform the matching operation
        if (matcher.find()) {
            System.out.println("Match found!"); // Print if a match is found
        } else {
            System.out.println("Match not found."); // Print if no match is found
        }
    }
}   

Output:

 
Match found!

Case Insensitivity with Complex Pattern

File Name: RegexExample2.java

 
import java.util.regex.*;
public class RegexExample2 {
    public static void main(String[] args) {
        // Regular expression pattern with multiple options
        String regex = "(?i)java";
        // Input string
        String input = "Java is fun, java is powerful, JAVA is everywhere!";
        // Compile the regular expression with CASE_INSENSITIVE embedded flag
        Pattern pattern = Pattern.compile(regex);
        // Create matcher object
        Matcher matcher = pattern.matcher(input);
        // Perform matching
        while (matcher.find()) {
            System.out.println("Match found at index: " + matcher.start());
        }
    }
}   

Output:

 
Match found at index: 0
Match found at index: 12
Match found at index: 29

Case Insensitivity with Groups

To use case insensitivity with regular expression groups in Java, we apply the same CASE_INSENSITIVE flag but include groups in pattern. Here's an example:

File Name: CaseInsensitiveGroupsExample.java

 
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class CaseInsensitiveGroupsExample {
    public static void main(String[] args) {
        // Define the regular expression pattern with groups
        String regex = "(name:\\s*(\\w+))\\s*\\(email:\\s*(\\S+)\\)";
        // Compile the pattern with case-insensitive flag
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        // Define the input string
        String input = "name: John (email: john.doe@example.com) " +
                       "name: alice (email: ALICE.SMITH@EXAMPLE.COM)";
        // Create a matcher for the input string
        Matcher matcher = pattern.matcher(input);
        // Find and print all matches
        while (matcher.find()) {
            System.out.println("Full match: " + matcher.group(0));
            System.out.println("Name group: " + matcher.group(1));
            System.out.println("Name: " + matcher.group(2));
            System.out.println("Email group: " + matcher.group(3));
            System.out.println();
        }
    }
}   

Output:

 
Full match: name: John (email: [email protected])
Name group: name: John
Name: John
Email group: [email protected]

Full match: name: alice (email: [email protected])
Name group: name: alice
Name: alice
Email group: [email protected]

2. Using Modifier

Alternatively, we can embed the (?i) modifier directly within the regex pattern itself. It applies case insensitivity locally to the part of the pattern where it is used.

File Name: UsingModifier.java

 
import java.util.regex.*;
public class UsingModifier{
    public static void main(String[] args) {
        // Define the regular expression pattern with case insensitivity modifier
        String regex = "(?i)hello";
        // Input string to search for matches
        String input = "Hello, World!";
        // Compile the regular expression
        Pattern pattern = Pattern.compile(regex);
        // Create a matcher object for the input string
        Matcher matcher = pattern.matcher(input);
        // Perform the matching operation
        if (matcher.find()) {
            System.out.println("Match found!"); // Print if a match is found
        } else {
            System.out.println("Match not found."); // Print if no match is found
        }
    }
}   

Output: