Regex #

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

String text = "I have 3 cats and 12 fish.";
String pattern = "\\d+"; // one or more digits

// Compile the pattern — do it once, store as a constant if used repeatedly
Pattern pattern = Pattern.compile(pattern);

// Create a Matcher for the target text
Matcher matcher = pattern.matcher(text);

// find() looks for the next match, returns true if found
while (matcher.find()) {
    System.out.println("Found: " + matcher.group());
    System.out.println("  position: " + matcher.start() + " - " + matcher.end());
}
// Output:
// Found: 3
//   position: 10 - 11
// Found: 12
//   position: 22 - 24

Pattern p = Pattern.compile("\\d+");

// matches(): the ENTIRE text must match the pattern — rarely used directly
Matcher m1 = p.matcher("123");
System.out.println(m1.matches()); // true — all of "123" is digits

Matcher m2 = p.matcher("123abc");
System.out.println(m2.matches()); // false — there's "abc" after

// find(): search for a match ANYWHERE in the text — most commonly used
Matcher m3 = p.matcher("abc 123 def");
System.out.println(m3.find()); // true — "123" found in the middle

// lookingAt(): matches from the START of the text, but doesn't have to reach the end
Matcher m4 = p.matcher("123abc");
System.out.println(m4.lookingAt()); // true — starts with digits

Matcher m5 = p.matcher("abc123");
System.out.println(m5.lookingAt()); // false — doesn't start with digits

// CASE_INSENSITIVE: ignore letter case
Pattern pInsensitive = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
System.out.println(pInsensitive.matcher("JAVA").matches()); // true
System.out.println(pInsensitive.matcher("Java").matches()); // true

// MULTILINE: ^ and $ match at the start/end of each line, not just the whole string
String multiline = "line 1\nline 2\nline 3";
Pattern pMulti = Pattern.compile("^line", Pattern.MULTILINE);
Matcher mMulti = pMulti.matcher(multiline);
int count = 0;
while (mMulti.find()) count++;
System.out.println(count); // 3 — found at the start of every line

// DOTALL: the dot (.) also matches newlines
Pattern pDotall = Pattern.compile("a.b", Pattern.DOTALL);
System.out.println(pDotall.matcher("a\nb").matches()); // true

// Combine multiple flags with bitwise OR
Pattern pCombined = Pattern.compile("java", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);

// Flags can also be written inline in the pattern
Pattern pInline = Pattern.compile("(?i)java"); // equivalent to CASE_INSENSITIVE

// Pattern: (year)-(month)-(day)
Pattern date = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
Matcher m = date.matcher("Birth date: 1995-07-20");

if (m.find()) {
    System.out.println("Full match: " + m.group(0)); // 1995-07-20
    System.out.println("Year:  " + m.group(1)); // 1995
    System.out.println("Month:  " + m.group(2)); // 07
    System.out.println("Day:   " + m.group(3)); // 20
}

// Named group syntax: (?<groupName>pattern)
Pattern date = Pattern.compile(
    "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})"
);
Matcher m = date.matcher("Date: 2025-08-17");

if (m.find()) {
    System.out.println("Year: " + m.group("year")); // 2025
    System.out.println("Month: " + m.group("month")); // 08
    System.out.println("Day:  " + m.group("day"));  // 17
}

// \1 refers to the text captured by the first group
// This pattern matches repeated words ("the the", "is is")
Pattern repeat = Pattern.compile("\\b(\\w+)\\s+\\1\\b");
Matcher m = repeat.matcher("this is is an example of a word that that repeats");

while (m.find()) {
    System.out.println("Repeated word: " + m.group(1));
}
// Output:
// Repeated word: is
// Repeated word: that

// Positive lookahead (?=...): matches only if followed by a specific pattern
// Find numbers followed by " USD"
Pattern price = Pattern.compile("\\d+(?= USD)");
Matcher m = price.matcher("Price: 500 USD and 300 EUR");
while (m.find()) {
    System.out.println(m.group()); // 500 (only the one followed by USD)
}

// Negative lookahead (?!...): matches only if NOT followed by a specific pattern
// Find numbers NOT followed by " USD"
Pattern notUSD = Pattern.compile("\\d+(?! USD)");
Matcher m2 = notUSD.matcher("Price: 500 USD and 300 EUR");
// will match "50" (part of 500) and "300" (followed by EUR)

// Positive lookbehind (?<=...): matches only if preceded by a specific pattern
// Find numbers preceded by "Rp"
Pattern rupiah = Pattern.compile("(?<=Rp)\\d+");
Matcher m = rupiah.matcher("Price: Rp50000 and USD300");
while (m.find()) {
    System.out.println(m.group()); // 50000
}

// Negative lookbehind (?<!...): matches only if NOT preceded by a specific pattern
Pattern notRupiah = Pattern.compile("(?<!Rp)\\d+");

// replaceAll via String (shortcut, no need to create a Pattern/Matcher)
String text = "Phone: 0812-3456-7890 and 0856-1234-5678";
String censored = text.replaceAll("\\d", "*");
System.out.println(censored);
// Phone: ****-****-**** and ****-****-****

// replaceFirst: only replace the first occurrence
String onlyFirst = text.replaceFirst("\\d+", "XXXX");
System.out.println(onlyFirst);
// Phone: XXXX-3456-7890 and 0856-1234-5678

// Use group references in the replacement: $1, $2, etc.
String date = "Date: 17/08/2025";
// Convert DD/MM/YYYY format → YYYY-MM-DD
String iso = date.replaceAll("(\\d{2})/(\\d{2})/(\\d{4})", "$3-$2-$1");
System.out.println(iso); // Date: 2025-08-17

// Java 9+: replaceAll(Function<MatchResult, String>) for custom logic
Pattern numbers = Pattern.compile("\\d+");
Matcher m = numbers.matcher("5 apples, 12 mangoes, 3 oranges");

// Double all the numbers
String result = m.replaceAll(mr -> String.valueOf(Integer.parseInt(mr.group()) * 2));
System.out.println(result);
// 10 apples, 24 mangoes, 6 oranges

// Split by one or more whitespace characters
String sentence = "  This   is   a   text   with   double   spaces  ";
String[] words = sentence.trim().split("\\s+");
System.out.println(words.length); // 6
// [This, is, a, text, with, double]

// Split by commas with optional spaces
String csv = "Budi, Ani,Citra ,Doni";
String[] names = csv.split("\\s*,\\s*");
// [Budi, Ani, Citra, Doni] — spaces around commas are removed too

// Split by several delimiters at once
String mixed = "one;two,three|four";
String[] parts = mixed.split("[;,|]");
// [one, two, three, four]

// Limit the number of parts with the limit parameter
String log = "ERROR:NullPointerException:line 42:long detail";
String[] parts = log.split(":", 3); // max 3 parts
// [ERROR, NullPointerException, line 42:long detail]

// ANTI-PATTERN: Pattern.compile() called on every iteration — very expensive
List<String> emails = getEmailList();
for (String email : emails) {
    if (Pattern.compile("^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$").matcher(email).matches()) {
        // process...
    }
}

// CORRECT: compile once as a static constant
private static final Pattern EMAIL_PATTERN =
    Pattern.compile("^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$");

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

// ANTI-PATTERN: patterns with nested quantifiers and overlapping alternation
// (a+)+ or (a|aa)+ on long input can run exponentially
Pattern dangerous = Pattern.compile("(a+)+b");
// "aaaaaaaaaaaaaaaaac" will hang the program due to unbounded backtracking

// CORRECT: avoid nested quantifiers, use atomic groups or possessive quantifiers
// Or use a more specific pattern
Pattern safe = Pattern.compile("a+b"); // simple, no nesting

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

// ANTI-PATTERN: greedy matches TOO MUCH
Pattern greedy = Pattern.compile("<.+>");
Matcher m1 = greedy.matcher(html);
if (m1.find()) System.out.println(m1.group());
// Output: <b>bold text</b> and <i>italic</i>  ← too wide!

// CORRECT: lazy matches as little as possible
Pattern lazy = Pattern.compile("<.+?>");
Matcher m2 = lazy.matcher(html);
while (m2.find()) System.out.println(m2.group());
// Output:
// <b>
// </b>
// <i>
// </i>

private static final Pattern EMAIL =
    Pattern.compile("^[\\w.+-]+@[\\w-]+\\.[a-zA-Z]{2,}(?:\\.[a-zA-Z]{2,})?$");

public static boolean isValidEmail(String email) {
    if (email == null) return false;
    return EMAIL.matcher(email).matches();
}

System.out.println(isValidEmail("[email protected]"));      // true
System.out.println(isValidEmail("[email protected]"));       // true
System.out.println(isValidEmail("not-an-email"));           // false
System.out.println(isValidEmail("@no-user.com"));       // false

// Format: 08XX-XXXX-XXXX or +628XX-XXXX-XXXX (hyphens optional)
private static final Pattern ID_PHONE = Pattern.compile(
    "^(\\+62|0)8[1-9][0-9][-\\s]?[0-9]{3,4}[-\\s]?[0-9]{3,4}$"
);

public static boolean isValidPhone(String number) {
    if (number == null) return false;
    return ID_PHONE.matcher(number.trim()).matches();
}

System.out.println(isValidPhone("081234567890"));   // true
System.out.println(isValidPhone("0812-3456-7890")); // true
System.out.println(isValidPhone("+628****7890")); // true
System.out.println(isValidPhone("1234567890"));     // false

private static final Pattern URL = Pattern.compile(
    "https?://[\\w.-]+(?:/[\\w./?=%&+-]*)?"
);

public static List<String> extractURLs(String text) {
    List<String> urls = new ArrayList<>();
    Matcher m = URL.matcher(text);
    while (m.find()) {
        urls.add(m.group());
    }
    return urls;
}

String article = "Visit https://java.unisbadri.com and https://docs.oracle.com/javase/ for references.";
List<String> found = extractURLs(article);
found.forEach(System.out::println);
// https://java.unisbadri.com
// https://docs.oracle.com/javase/

private static final Pattern IP = Pattern.compile(
    "\\b(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\b"
);

String log = """
    2025-08-17 ERROR request from 192.168.1.10 failed
    2025-08-17 INFO  access from 10.0.0.254 succeeded
    2025-08-17 WARN  attempt from 999.999.999.999 rejected
    """;

Matcher m = IP.matcher(log);
while (m.find()) {
    System.out.println("IP: " + m.group());
}
// IP: 192.168.1.10
// IP: 10.0.0.254
// (999.999.999.999 doesn't match — values exceed 255)

// Convert all DD/MM/YYYY dates to YYYY-MM-DD in a document
private static final Pattern ID_DATE =
    Pattern.compile("(?<day>\\d{2})/(?<month>\\d{2})/(?<year>\\d{4})");

public static String reformat(String text) {
    return ID_DATE.matcher(text)
        .replaceAll(mr -> mr.group("year") + "-" + mr.group("month") + "-" + mr.group("day"));
}

String document = "The contract was signed on 17/08/2025 and valid until 31/12/2027.";
System.out.println(reformat(document));
// The contract was signed on 2025-08-17 and valid until 2027-12-31.