Understand the idea

A regular expression describes a set of text patterns. matches checks the entire input; find searches for a matching region. Keep Java string escaping separate from regex escaping when a pattern contains backslashes.

Explore the details

What is a Regular Expression?

A regular expression is a sequence of characters that forms a search pattern. When you search for data in a text, you can use this search pattern to describe what you are searching for.

A regular expression can be a single character, or a more complicated pattern.

Regular expressions can be used to perform all types of text search and text replace operations.

Java does not have a built-in Regular Expression class, but we can import the java.util.regex package to work with regular expressions. The package includes the following classes:

• Pattern Class – Defines a pattern (to be used in a search)
• Matcher Class – Used to search for the pattern
• PatternSyntaxException Class – Indicates syntax error in a regular expression pattern

Example Explained

In this example, The word "codingtamilan" is being searched for in a sentence.

First, the pattern is created using the Pattern.compile() method. The first parameter indicates which pattern is being searched for and the second parameter has a flag to indicates that the search should be case-insensitive. The second parameter is optional.

The matcher() method is used to search for the pattern in a string. It returns a Matcher object which contains information about the search that was performed.

The find() method returns true if the pattern was found in the string and false if it was not found.

import java.util.regex.*;

// Basic match
Pattern p = Pattern.compile("codingtamilan", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("I love CodingTamilan!");
System.out.println(m.find());   // true

// Full-string match
System.out.println("Hello".matches("[A-Z][a-z]+"));  // true

// Find all occurrences
Pattern pAll = Pattern.compile("cat");
Matcher mAll = pAll.matcher("cat and cats and catch");
while (mAll.find()) {
    System.out.println("Found at index " + mAll.start());
}
// Found at index 0
// Found at index 8
// Found at index 17

Flags

Flags in the compile() method change how the search is performed. Here are a few of them:

• Pattern.CASE_INSENSITIVE – The case of letters will be ignored when performing a search.
• Pattern.LITERAL – Special characters in the pattern will not have any special meaning and will be treated as ordinary characters when performing a search.
• Pattern.UNICODE_CASE – Use it together with the CASE_INSENSITIVE flag to also ignore the case of letters outside of the English alphabet

Regular Expression Patterns

The first parameter of the Pattern.compile() method is the pattern. It describes what is being searched for.

Brackets are used to find a range of characters:

Metacharacters

Metacharacters are characters with a special meaning:

Quantifiers

Quantifiers define quantities:

Real-World Regex Examples

// String.matches() — full-string regex test
String email = "user@example.com";
System.out.println(email.matches("[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}")); // true

// replaceAll — remove all non-digits
String cleaned = "Phone: 98-765-43210".replaceAll("\\D", "");
System.out.println(cleaned);   // 9876543210

// split by whitespace
String[] words = "hello  world  java".split("\\s+");
System.out.println(Arrays.toString(words)); // [hello, world, java]

A complete runnable example

This complete Main.java program focuses on the lesson idea. Reference fragments above may demonstrate individual statements; this example includes the imports, entry point, and supporting types it needs.

import java.util.regex.Pattern;
public class Main {
    public static void main(String[] args) throws Exception {
        System.out.println(Pattern.matches("[A-Z][0-9]{3}", "A123"));
        System.out.println(Pattern.matches("[A-Z][0-9]{3}", "A1234"));
    }
}

true
false

Change it. Run it. Understand it.

Load this lesson example into the editor. Change one value or statement, predict the result, then press RUN to execute Java.

Make it your own

Your learning checkpoint

• Explain the example without reading the output first.
• Make the change requested in the practice task.
• Describe why the result changed—or why compilation failed.

Ready to move on? Follow the next lesson in course order, or return to the curriculum to review a prerequisite.