Regular Expressions in Java

1. What is Regex?

A regular expression (regex) is a sequence of characters that defines a search pattern. Regex engines scan input text and identify portions that match the specified pattern. Java provides built-in regex support through the java.util.regex package, available since JDK 1.4.

Common use cases include:

• Validation — verify that an email address, phone number, or postal code is correctly formatted.
• Search — locate one or more occurrences of a pattern within a larger string.
• Replace — substitute matched substrings with new content.
• Split — break a string into tokens using a delimiter pattern.
• Extract — pull out specific data (dates, prices, URLs) from unstructured text.

2. Key Classes

The java.util.regex package contains three primary classes:

3. Basic Pattern Matching

The simplest workflow: compile a pattern, create a matcher for the input, then call matches() to test whether the entire input matches the pattern.

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

public class BasicMatch {
    public static void main(String[] args) {
        String pattern = "\\d{3}-\\d{4}";   // e.g. 555-1234
        String input   = "555-1234";

        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(input);

        if (m.matches()) {
            System.out.println("Input matches the pattern.");
        } else {
            System.out.println("No match.");
        }
    }
}

4. Pattern Class

The Pattern class is the entry point for all regex operations. Its key static and instance methods are:

compile()

Compiles the regex string into a reusable Pattern object. Optionally accepts flags such as Pattern.CASE_INSENSITIVE.

Pattern p = Pattern.compile("[a-z]+", Pattern.CASE_INSENSITIVE);

matcher()

Creates a Matcher bound to the given input string.

Matcher m = p.matcher("Hello World");

matches() — static shortcut

Compiles and matches in one call. Convenient for one-off checks.

boolean ok = Pattern.matches("\\d+", "12345");  // true

split()

Splits the input string around matches of the pattern — similar to String.split() but with a pre-compiled pattern.

Pattern p = Pattern.compile("[,;\\s]+");
String[] tokens = p.split("one, two;  three four");
for (String t : tokens) System.out.println(t);

5. Matcher Class

A Matcher performs the actual searching. Key methods:

find()

Advances through the input and returns true each time a new match is found. Ideal for iterating over all occurrences.

Pattern p = Pattern.compile("\\d+");
Matcher m = p.matcher("Order 42, item 7, qty 100");
while (m.find()) {
    System.out.println("Found: " + m.group() + " at index " + m.start());
}

group(), start(), end()

After a successful find() or matches(), these methods return the matched substring, its start index, and its end index respectively.

Pattern p = Pattern.compile("(\\w+)@(\\w+\\.\\w+)");
Matcher m = p.matcher("Contact: alice@example.com today.");
if (m.find()) {
    System.out.println("Full match : " + m.group(0));
    System.out.println("Username   : " + m.group(1));
    System.out.println("Domain     : " + m.group(2));
    System.out.println("Start/End  : " + m.start() + " / " + m.end());
}

replaceAll()

Replaces every match in the input with the given replacement string.

String result = Pattern.compile("\\bfoo\\b")
                       .matcher("foo foobar foo")
                       .replaceAll("bar");
System.out.println(result);

6. Character Classes

Character classes match a single character against a set of allowed characters defined inside square brackets.

7. Predefined Character Classes

Java regex provides shorthand escape sequences for common character groups.

8. Quantifiers

Quantifiers specify how many times a preceding element must occur to constitute a match.

By default, quantifiers are greedy — they match as much as possible. Append ? to make them lazy (e.g. .*?) — match as little as possible.

9. Anchors and Boundaries

Anchors do not consume characters; they assert a position in the input string.

Pattern p = Pattern.compile("^\\d{4}$");
System.out.println(p.matcher("2024").matches());     // true
System.out.println(p.matcher("20245").matches());    // false
System.out.println(p.matcher("abc").matches());      // false

10. Common Practical Examples

Email Validation

public static boolean isValidEmail(String email) {
    String regex = "^[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}$";
    return Pattern.matches(regex, email);
}

System.out.println(isValidEmail("user@example.com"));   // true
System.out.println(isValidEmail("bad-email@"));         // false
System.out.println(isValidEmail("also.bad@.com"));      // false

Phone Number Validation (US format)

public static boolean isValidPhone(String phone) {
    // Accepts: (123) 456-7890, 123-456-7890, 1234567890
    String regex = "^(\\(\\d{3}\\)\\s?|\\d{3}[-.]?)\\d{3}[-.]?\\d{4}$";
    return Pattern.matches(regex, phone);
}

System.out.println(isValidPhone("(800) 555-1234"));   // true
System.out.println(isValidPhone("800-555-1234"));     // true
System.out.println(isValidPhone("8005551234"));       // true
System.out.println(isValidPhone("1234"));             // false

URL Pattern Extraction

String text = "Visit https://www.example.com or http://docs.java.net for more.";
Pattern p = Pattern.compile("https?://[\\w./-]+");
Matcher m = p.matcher(text);
while (m.find()) {
    System.out.println("URL: " + m.group());
}

11. String Regex Methods

The String class provides convenient regex shortcuts that do not require creating Pattern or Matcher objects explicitly.

matches()

Tests whether the entire string matches the given regex. Equivalent to Pattern.matches(regex, str).

String s = "hello123";
System.out.println(s.matches("[a-z]+\\d+"));   // true
System.out.println(s.matches("[a-z]+"));       // false (digits not covered)

replaceAll()

Replaces every substring matching the regex with the replacement. Internally creates a new Pattern on each call — cache a Pattern when calling in a loop.

String cleaned = "Hello   World  !".replaceAll("\\s+", " ");
System.out.println(cleaned);

split()

Splits the string at each point where the regex matches, returning a String[].

String csv = "apple, banana,  cherry,date";
String[] fruits = csv.split(",\\s*");
for (String f : fruits) System.out.println(f);