Java Regular Expressions

// 1. Compile the pattern (expensive — do once, reuse)
Pattern pattern = Pattern.compile("\\d{3}-\\d{4}");

// 2. Create a matcher against input
Matcher matcher = pattern.matcher("Call 555-1234 now");

// 3. Use matcher methods
if (matcher.find()) {
    System.out.println(matcher.group()); // "555-1234"
    System.out.println(matcher.start()); // 5
    System.out.println(matcher.end());   // 13
}

// Combine flags with bitwise OR
Pattern p = Pattern.compile("hello world",
        Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);

// Or embed flags inline
Pattern p2 = Pattern.compile("(?im)hello world");

String input = "<b>bold</b> and <i>italic</i>";

// Greedy: matches as much as possible, then backtracks
Pattern greedy = Pattern.compile("<.+>");
// Matches: "<b>bold</b> and <i>italic</i>"  (one huge match)

// Reluctant: matches as little as possible
Pattern reluctant = Pattern.compile("<.+?>");
// Matches: "<b>", "</b>", "<i>", "</i>"  (four separate matches)

// Possessive: matches as much as possible, NO backtracking
Pattern possessive = Pattern.compile("<.++>");
// No match at all! Consumes everything, won't give back the ">"

// \b ensures we match whole words only
Pattern p = Pattern.compile("\\bcat\\b");
Matcher m = p.matcher("concatenate the cat in the catalog");
// Finds only "cat" at position 18, not inside "concatenate" or "catalog"

Pattern datePattern = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
Matcher m = datePattern.matcher("Date: 2025-07-15");

if (m.find()) {
    System.out.println(m.group(0)); // "2025-07-15"  (full match)
    System.out.println(m.group(1)); // "2025"        (year)
    System.out.println(m.group(2)); // "07"          (month)
    System.out.println(m.group(3)); // "15"          (day)
}

Pattern p = Pattern.compile(
    "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})");
Matcher m = p.matcher("2025-07-15");

if (m.find()) {
    System.out.println(m.group("year"));  // "2025"
    System.out.println(m.group("month")); // "07"
    System.out.println(m.group("day"));   // "15"
}

// Non-capturing: groups for alternation without creating a capture
Pattern p = Pattern.compile("(?:http|https)://(.+)");
Matcher m = p.matcher("https://example.com");

if (m.find()) {
    System.out.println(m.group(1)); // "example.com" — group 1, not 2
}

// Find repeated words
Pattern p = Pattern.compile("\\b(\\w+)\\s+\\1\\b", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("The the quick brown fox fox jumped");

while (m.find()) {
    System.out.println("Duplicate: " + m.group()); 
    // "The the"
    // "fox fox"
}

// Named backreference
Pattern p = Pattern.compile("(?<tag>\\w+)=\\k<tag>");
Matcher m = p.matcher("test=test value=value bad=wrong");

while (m.find()) {
    System.out.println(m.group()); // "test=test", "value=value"
}

// Password validation: at least 8 chars, one uppercase, one digit, one special
Pattern strongPassword = Pattern.compile(
    "^(?=.*[A-Z])(?=.*\\d)(?=.*[@#$%^&+=!]).{8,}$"
);

System.out.println(strongPassword.matcher("Passw0rd!").matches());  // true
System.out.println(strongPassword.matcher("weakpass").matches());   // false

// Lookbehind: extract amounts after a dollar sign
Pattern p = Pattern.compile("(?<=\\$)\\d+\\.\\d{2}");
Matcher m = p.matcher("Price: $49.99 and $12.50");

while (m.find()) {
    System.out.println(m.group()); // "49.99", "12.50" (without the $)
}

// Negative lookahead: find "foo" NOT followed by "bar"
Pattern p = Pattern.compile("foo(?!bar)");
Matcher m = p.matcher("foobar foobaz foo");

while (m.find()) {
    System.out.println(m.start()); // 7 ("foobaz"), 14 ("foo")
}

String input = "Hello, World!";

// matches() — entire string must match
input.matches("[A-Za-z, !]+");  // true

// split() — split on a pattern
"one:two::three".split(":");     // ["one", "two", "", "three"]
"one:two::three".split(":", 3);  // ["one", "two", ":three"] (limit = 3 parts)
"one:two::three".split(":", -1); // ["one", "two", "", "three"] (keep trailing empties)

// replaceAll() — replace all matches
"2025-07-15".replaceAll("(\\d{4})-(\\d{2})-(\\d{2})", "$2/$3/$1");
// Result: "07/15/2025"

// replaceFirst() — replace first match only
"aaa bbb aaa".replaceFirst("aaa", "ccc");  // "ccc bbb aaa"

// BAD: recompiles pattern on every iteration — O(n * compile_cost)
for (String email : emails) {
    if (email.matches("[\\w.]+@[\\w.]+\\.\\w+")) {
        // ...
    }
}

// GOOD: compile once, reuse — O(compile_cost + n * match_cost)
private static final Pattern EMAIL_PATTERN = 
    Pattern.compile("[\\w.]+@[\\w.]+\\.\\w+");

for (String email : emails) {
    if (EMAIL_PATTERN.matcher(email).matches()) {
        // ...
    }
}

// Email (simplified — RFC 5322 is much more complex)
Pattern EMAIL = Pattern.compile(
    "^[\\w.%+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$"
);

// US Phone Number (flexible format)
Pattern PHONE = Pattern.compile(
    "^\\(?\\d{3}\\)?[-.\\s]?\\d{3}[-.\\s]?\\d{4}$"
);

// IPv4 Address
Pattern IPV4 = Pattern.compile(
    "^((25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$"
);

// URL (http/https)
Pattern URL = Pattern.compile(
    "^https?://[\\w.-]+(?:\\.[a-zA-Z]{2,})(?:/[\\w./?%&=+-]*)?$"
);

// Java identifier
Pattern IDENTIFIER = Pattern.compile(
    "^[a-zA-Z_$][a-zA-Z0-9_$]*$"
);

// ISO date (YYYY-MM-DD)
Pattern ISO_DATE = Pattern.compile(
    "^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$"
);

// VULNERABLE: nested quantifiers create exponential backtracking
Pattern bad = Pattern.compile("(a+)+b");

// Benign input: matches quickly
bad.matcher("aaaaab").matches(); // true, fast

// Malicious input: no match, but engine tries every combination
bad.matcher("aaaaaaaaaaaaaaaaaaaaa!").matches(); 
// Takes seconds... minutes... hangs!

// SAFE: possessive quantifier prevents backtracking
Pattern safe = Pattern.compile("(a++)b");
safe.matcher("aaaaaaaaaaaaaaaaaaaaa!").matches(); // false, instant

// SAFE: atomic group (equivalent to possessive)
Pattern atomic = Pattern.compile("(?>a+)b");
atomic.matcher("aaaaaaaaaaaaaaaaaaaaa!").matches(); // false, instant

// Java 9+: Stream-based matching
Pattern p = Pattern.compile("\\b\\w{5}\\b");
List<String> fiveLetterWords = p.matcher("Hello brave new world today")
    .results()
    .map(MatchResult::group)
    .collect(Collectors.toList());
// ["Hello", "brave", "world", "today"]

// Java 9+: Use as a predicate for filtering
Pattern emailPattern = Pattern.compile("[\\w.]+@[\\w.]+\\.\\w+");
Predicate<String> isEmail = emailPattern.asMatchPredicate();

List<String> validEmails = candidates.stream()
    .filter(isEmail)
    .collect(Collectors.toList());