Java Regular Expressions (Regex)

A regular expression (regex) is a pattern that describes a set of matching strings, and Java provides full regex support through the java.util.regex package as well as several regex-powered methods directly on the String class. Regex is the standard tool for validating input formats (emails, phone numbers, postal codes), searching text, and performing pattern-based replacements.

Why it matters

Regular expressions describe a text pattern in one line: a valid phone number, a date, every number in a log line. They are how input is validated and text is extracted in most real applications. They are also easy to get subtly wrong, so it pays to know exactly what matches() checks and how backslashes are written inside a Java string.

The Pattern and Matcher Classes

Pattern.compile(regex) compiles a regular expression string into a reusable Pattern object — compiling once and reusing the Pattern is more efficient than recompiling the same regex repeatedly. Calling pattern.matcher(input) produces a Matcher object bound to a specific input string, which provides methods like matches() (does the entire input match the pattern), find() (is there a matching subsequence anywhere in the input), and group() (retrieve the text that matched).

Common Regex Metacharacters

A small set of metacharacters covers the vast majority of everyday patterns.

• . — matches any single character (except line terminators by default).
• * and + — zero-or-more and one-or-more repetitions of the preceding element.
• ? — zero-or-one occurrence (also used to make a quantifier non-greedy, as in *?).
• \d and \w — a single digit (0-9) and a single "word" character (letters, digits, underscore) respectively.
• ^ and $ — anchor a match to the start and end of the input (or line, in multiline mode).

Regex-Powered String Methods

You rarely need Pattern and Matcher directly for simple cases, because String itself exposes convenient regex-based methods: matches(regex) checks whether the entire string matches a pattern, replaceAll(regex, replacement) replaces every matching subsequence, and split(regex) breaks a string into an array wherever the pattern matches. These cover most validation and parsing needs without ever constructing a Pattern object explicitly.

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo {
    public static void main(String[] args) {
        String email = "user@example.com";
        String regex = "^[\\w.]+@[\\w]+\\.[a-zA-Z]{2,}$";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(email);

        System.out.println(matcher.matches());
        System.out.println(email.matches(regex));
        System.out.println("2026-09-21".replaceAll("-", "/"));
    }
}

true
true
2026/09/21

Exercise

Validate an Indian PIN code: it must be exactly six digits and must not start with 0.

Expected output: true for 110001, false for 012345, and false for 1100.

public class PinCode {

    static boolean isValidPin(String pin) {
        // TODO: return true only for six digits where the first is 1-9
        return false;
    }

    public static void main(String[] args) {
        System.out.println(isValidPin("110001"));
        System.out.println(isValidPin("012345"));
        System.out.println(isValidPin("1100"));
    }
}

public class PinCode {

    static boolean isValidPin(String pin) {
        return pin.matches("[1-9][0-9]{5}");
    }

    public static void main(String[] args) {
        System.out.println(isValidPin("110001")); // true
        System.out.println(isValidPin("012345")); // false
        System.out.println(isValidPin("1100"));   // false
    }
}

Quick quiz

Interview questions