Java Regular Expressions Explained — Patterns, Matching and Real-World Usage

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

public class EmailValidator {

    // Compile ONCE as a static constant — never recompile inside a method
    // that gets called repeatedly. This is the single biggest regex
    // performance win in Java.
    private static final Pattern EMAIL_PATTERN = Pattern.compile(
        "^[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}$"
    );

    public static boolean isValidEmail(String email) {
        if (email == null) return false;

        // Matcher ties the compiled pattern to a specific input string
        Matcher matcher = EMAIL_PATTERN.matcher(email);

        // matches() checks whether the ENTIRE string fits the pattern
        // (anchors ^ and $ make this explicit but matches() implies them)
        return matcher.matches();
    }

    public static void main(String[] args) {
        String[] testEmails = {
            "alice@example.com",        // valid
            "bob.smith+filter@work.org", // valid — plus and dot are allowed
            "charlie@",                  // invalid — no domain
            "dave @spaces.com",          // invalid — space in local part
            "eve@domain.c"               // invalid — TLD too short
        };

        for (String email : testEmails) {
            System.out.printf("%-30s -> %s%n",
                email,
                isValidEmail(email) ? "VALID" : "INVALID"
            );
        }
    }
}

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

public class LogParser {

    // Pattern to pull an ISO timestamp out of an application log line
    // Group 1: date (YYYY-MM-DD)
    // Group 2: time (HH:MM:SS)
    // Group 3: log level (INFO, WARN, ERROR)
    private static final Pattern LOG_ENTRY_PATTERN = Pattern.compile(
        "(\\d{4}-\\d{2}-\\d{2}) (\\d{2}:\\d{2}:\\d{2}) \\[(INFO|WARN|ERROR)\\]"
    );

    public static void main(String[] args) {
        String logOutput =
            "2024-03-15 08:30:01 [INFO] Application started\n" +
            "2024-03-15 08:30:45 [WARN] Memory usage at 78%\n" +
            "2024-03-15 08:31:02 [ERROR] Database connection refused\n" +
            "2024-03-15 08:31:10 [INFO] Retry attempt 1\n";

        // --- Demonstrating the difference between the three methods ---

        String singleLine = "2024-03-15 08:30:01 [INFO] Application started";
        Matcher fullLineMatcher = LOG_ENTRY_PATTERN.matcher(singleLine);

        // matches() returns false — pattern doesn't cover the WHOLE string
        // because " Application started" is not part of our pattern
        System.out.println("matches() on full line: " + fullLineMatcher.matches());

        // Reset the matcher so we can reuse it (avoids creating a new Matcher)
        fullLineMatcher.reset();

        // lookingAt() returns true — our pattern matches at the START
        System.out.println("lookingAt() on full line: " + fullLineMatcher.lookingAt());

        System.out.println("\n--- Parsing all log entries with find() ---");

        List<String> errorTimestamps = new ArrayList<>();
        Matcher logMatcher = LOG_ENTRY_PATTERN.matcher(logOutput);

        // find() advances through the entire multi-line string
        // each call moves the cursor past the last match
        while (logMatcher.find()) {
            String date      = logMatcher.group(1); // first capture group
            String time      = logMatcher.group(2); // second capture group
            String level     = logMatcher.group(3); // third capture group

            System.out.printf("Date: %s | Time: %s | Level: %s%n", date, time, level);

            if ("ERROR".equals(level)) {
                errorTimestamps.add(date + " " + time);
            }
        }

        System.out.println("\nErrors occurred at: " + errorTimestamps);
    }
}

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

public class DateReformatter {

    // Named groups make this readable six months later when you revisit the code
    // (?<month>\d{1,2}) — named group 'month', 1 or 2 digits
    // (?<day>\d{1,2})   — named group 'day'
    // (?<year>\d{4})    — named group 'year', exactly 4 digits
    private static final Pattern US_DATE_PATTERN = Pattern.compile(
        "(?<month>\\d{1,2})/(?<day>\\d{1,2})/(?<year>\\d{4})"
    );

    /**
     * Converts all US-format dates (M/D/YYYY) in a string to ISO-8601 (YYYY-MM-DD).
     * A real use case: normalising dates from a CSV export before inserting to a DB.
     */
    public static String convertToIso(String rawText) {
        Matcher matcher = US_DATE_PATTERN.matcher(rawText);

        // The replacement string uses ${name} to refer to named groups.
        // %02d-style zero-padding isn't available here, so we handle that below.
        // Instead, we use appendReplacement for full control over the output.
        StringBuffer result = new StringBuffer();

        while (matcher.find()) {
            String year  = matcher.group("year");
            // Zero-pad month and day to always produce 2-digit output
            String month = String.format("%02d", Integer.parseInt(matcher.group("month")));
            String day   = String.format("%02d", Integer.parseInt(matcher.group("day")));

            // appendReplacement writes everything between the last match and this
            // match verbatim, then substitutes our custom replacement string
            matcher.appendReplacement(result, year + "-" + month + "-" + day);
        }

        // appendTail writes any text that follows the last match
        matcher.appendTail(result);
        return result.toString();
    }

    public static void main(String[] args) {
        String importedData =
            "Invoice 1: due 3/5/2024, Invoice 2: due 11/20/2024, Invoice 3: due 1/1/2025";

        System.out.println("Original : " + importedData);
        System.out.println("Converted: " + convertToIso(importedData));

        // Bonus: quick demonstration of simple replaceAll with backreferences
        // Swap 'firstName lastName' to 'lastName, firstName' in a list
        String nameList = "Alice Johnson, Bob Smith, Carol White";
        // \b ensures we match whole words; group 1 = first name, group 2 = last name
        String reordered = nameList.replaceAll(
            "\\b([A-Z][a-z]+) ([A-Z][a-z]+)\\b",
            "$2, $1"  // $1 and $2 refer to captured groups by number
        );
        System.out.println("\nOriginal names : " + nameList);
        System.out.println("Reordered names: " + reordered);
    }
}