Java Regex Exercises: 30 Coding Problems with Solutions

public class Main {
    public static void main(String[] args) {
        String regex = "Java";

        System.out.println("Java".matches(regex));
        System.out.println("java".matches(regex));
        System.out.println("JAVA".matches(regex));
    }
}Code language: Java (java)

Explanation:

• String regex = "Java": A literal pattern with no special regex syntax at all. It matches only the exact sequence of characters J, a, v, a.
• "Java".matches(regex): Returns true since the input is character-for-character identical to the pattern.
• "java".matches(regex) and "JAVA".matches(regex): Both return false, since regex matching distinguishes between uppercase and lowercase letters unless told otherwise.
• Whole-string matching: matches() implicitly anchors the pattern to both the start and end of the input, unlike some other regex methods that only look for a match anywhere inside the string.

public class Main {
    public static void main(String[] args) {
        String regex = "(?i)java";

        System.out.println("Java".matches(regex));
        System.out.println("JAVA".matches(regex));
        System.out.println("JaVa".matches(regex));
    }
}Code language: Java (java)

Explanation:

• (?i): An inline flag that turns on case-insensitive matching for the remainder of the pattern, embedded directly in the regex string itself.
• (?i)java: With the flag active, this pattern now matches java, Java, JAVA, and any other capitalization combination of the same four letters.
• All three inputs return true: Since the flag ignores case entirely, the specific mix of uppercase and lowercase letters in each test string no longer matters.
• Alternative: Pattern.compile("java", Pattern.CASE_INSENSITIVE) achieves the same result using a compiled Pattern object and an explicit flag constant instead of the inline syntax.

public class Main {
    public static void main(String[] args) {
        String regex = "\\d{5}";

        System.out.println("90210".matches(regex));
        System.out.println("9021".matches(regex));
        System.out.println("902100".matches(regex));
    }
}Code language: Java (java)

Explanation:

• \\d: In the Java string literal, this represents the single regex token \d, which matches any one digit character.
• {5}: An exact-count quantifier, requiring precisely 5 digits in a row, no more and no fewer.
• "9021".matches(regex): Returns false because the string only has 4 digits, one short of the required count.
• "902100".matches(regex): Returns false because the string has 6 digits, one too many, since matches() requires the entire string to satisfy the pattern.

public class Main {
    public static void main(String[] args) {
        String regex = "[a-zA-Z0-9]+";

        System.out.println("Java123".matches(regex));
        System.out.println("Java 123".matches(regex));
        System.out.println("Java_123".matches(regex));
    }
}Code language: Java (java)

Explanation:

• [a-zA-Z0-9]: A character class combining three ranges: lowercase letters, uppercase letters, and digits, so any single character from any of those three ranges counts as a match.
• +: Requires the entire string to consist of one or more characters from that character class, with nothing else mixed in.
• "Java 123".matches(regex): Returns false because the space character is not part of the allowed character class.
• "Java_123".matches(regex): Returns false because the underscore is also outside the defined ranges, even though underscores are sometimes informally grouped with “alphanumeric” characters.

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

public class Main {
    public static void main(String[] args) {
        String regex = "[AEIOUaeiou]";
        String input = "Regular Expressions are Powerful";

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

        int count = 0;
        while (matcher.find()) {
            count++;
        }

        System.out.println("Vowel count: " + count);
    }
}Code language: Java (java)

Explanation:

• [AEIOUaeiou]: A character class listing all five vowels in both uppercase and lowercase, so any single one of those ten characters counts as a match.
• Pattern.compile(regex): Compiles the pattern once into a reusable Pattern object, which is more efficient than recompiling the same regex on every match attempt.
• pattern.matcher(input): Creates a Matcher tied to this specific input string, ready to search through it for matches.
• while (matcher.find()): Each call to find() locates the next vowel starting from wherever the previous match left off, letting the loop count every single vowel in the string.

public class Main {
    public static void main(String[] args) {
        String regex = "[^0-9]*";

        System.out.println("Hello World".matches(regex));
        System.out.println("Hello123".matches(regex));
    }
}Code language: Java (java)

Explanation:

• [^0-9]: The caret at the start of the character class inverts it, so this matches any character that is not one of the digits 0 through 9, including letters, spaces, and punctuation.
• *: Allows zero or more of those non-digit characters, so the entire string is accepted as long as it never contains a digit anywhere.
• "Hello World".matches(regex): Returns true, since letters and the space character are all outside the negated digit class.
• "Hello123".matches(regex): Returns false, since the digits 1, 2, and 3 fall inside the excluded range, breaking the match for the whole string.
• Alternative: "\\D*" uses the built-in shorthand for “non-digit” and behaves identically to the custom negated character class shown here.

public class Main {
    public static void main(String[] args) {
        String regex = "[A-Za-z]\\d{3}";

        System.out.println("A123".matches(regex));
        System.out.println("z987".matches(regex));
        System.out.println("AB123".matches(regex));
        System.out.println("A12".matches(regex));
    }
}Code language: Java (java)

Explanation:

• [A-Za-z]: Matches exactly one letter, either uppercase or lowercase, since a character class with no quantifier always matches a single character.
• \\d{3}: Immediately requires exactly 3 digits right after that letter, with no separator or gap allowed between them.
• "AB123".matches(regex): Returns false because there are two letters at the start instead of one, which the pattern does not allow.
• "A12".matches(regex): Returns false because only 2 digits follow the letter, one short of the required 3.

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

public class Main {
    public static void main(String[] args) {
        String regex = "\\bcat\\b";
        String input = "The cat sat near the category and the bobcat.";

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

        while (matcher.find()) {
            System.out.println("Match found at index: " + matcher.start());
        }
    }
}Code language: Java (java)

Explanation:

• \\bcat\\b: Requires a word boundary immediately before the c and immediately after the second t, ensuring cat is not attached to any other letters on either side.
• Why "category" does not match: Although it starts with cat, the character immediately after those three letters is e, another word character, so there is no word boundary there and the match fails.
• Why "bobcat" does not match: The character immediately before cat is b, another word character, so there is no word boundary on that side either.
• matcher.start(): Reports the index where the current match begins in the original string, which is 4 for the standalone "cat" in "The cat sat...".

public class Main {
    public static void main(String[] args) {
        String regex = "[A-Z].*\\.";

        System.out.println("This is a sentence.".matches(regex));
        System.out.println("this is a sentence.".matches(regex));
        System.out.println("This is a sentence".matches(regex));
    }
}Code language: Java (java)

Explanation:

• [A-Z]: Requires the first character of the string to be an uppercase letter, immediately ruling out sentences that start lowercase.
• .*: Matches any sequence of characters, including none at all, filling the gap between the required first letter and the required final period.
• \\.: Matches a literal period character. Without the backslash, a plain . in regex means “any character”, not specifically a period.
• "This is a sentence".matches(regex): Returns false because the string has no trailing period at all, failing the final required character.

public class Main {
    public static void main(String[] args) {
        String regex = "#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})";

        System.out.println("#FFF".matches(regex));
        System.out.println("#abc123".matches(regex));
        System.out.println("#12A4B6".matches(regex));
        System.out.println("#12345".matches(regex));
        System.out.println("123456".matches(regex));
    }
}Code language: Java (java)

Explanation:

• #: Matched literally at the very start, requiring every valid input to begin with the hash symbol used in CSS hex color syntax.
• ([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3}): A group containing two alternatives joined by |, matching either exactly 6 hex digits or exactly 3, covering both the shorthand and full CSS hex formats.
• "#12345".matches(regex): Returns false because 5 digits satisfies neither the 6-digit nor the 3-digit alternative.
• "123456".matches(regex): Returns false because the string is missing the required leading #, even though the 6 hex digits themselves would otherwise be valid.

public class Main {
    public static void main(String[] args) {
        String input = "   Hello World   ";
        String regex = "^\\s+|\\s+$";

        String trimmed = input.replaceAll(regex, "");
        System.out.println("\"" + trimmed + "\"");
    }
}Code language: Java (java)

Explanation:

• ^\\s+: Matches one or more whitespace characters anchored to the very beginning of the string.
• \\s+$: Matches one or more whitespace characters anchored to the very end of the string.
• |: Combines both alternatives, so replaceAll() strips matches from either end without touching whitespace in the middle of the string.
• input.replaceAll(regex, ""): Replaces every match with an empty string, effectively deleting the leading and trailing whitespace while leaving the single space between Hello and World untouched.

public class Main {
    public static void main(String[] args) {
        String regex = "[01]+";

        System.out.println("101010".matches(regex));
        System.out.println("10102".matches(regex));
        System.out.println("".matches(regex));
    }
}Code language: Java (java)

Explanation:

• [01]: A character class containing only two possible characters, 0 and 1, matching one binary digit at a time.
• +: Requires at least one character from the class, so the whole string must consist entirely of 0s and 1s, with at least one digit present.
• "10102".matches(regex): Returns false because the digit 2 falls outside the allowed character class.
• "".matches(regex): Returns false because + requires at least one matching character, and an empty string has none.

public class Main {
    public static void main(String[] args) {
        String regex = "[a-zA-Z_$][a-zA-Z0-9_$]*";

        System.out.println("_count".matches(regex));
        System.out.println("$value".matches(regex));
        System.out.println("2ndPlace".matches(regex));
        System.out.println("user_Name1".matches(regex));
    }
}Code language: Java (java)

Explanation:

• [a-zA-Z_$]: Matches exactly one character for the required first position, restricted to letters, underscore, or dollar sign, deliberately excluding digits.
• [a-zA-Z0-9_$]*: Matches zero or more characters for everything after the first position, this time including digits as well.
• "2ndPlace".matches(regex): Returns false because the very first character is a digit, which the first character class does not permit.
• "user_Name1".matches(regex): Returns true, since it starts with a letter and every character after that, including the underscore and trailing digit, falls within the second, broader character class.

public class Main {
    public static void main(String[] args) {
        String regex = "\\d{4}-\\d{2}-\\d{2}";

        System.out.println("2026-12-31".matches(regex));
        System.out.println("26-12-31".matches(regex));
        System.out.println("2026/12/31".matches(regex));
    }
}Code language: Java (java)

Explanation:

• \\d{4}: Matches exactly 4 digits for the year portion.
• -\\d{2}-\\d{2}: Matches a literal hyphen, exactly 2 digits for the month, another literal hyphen, and exactly 2 digits for the day.
• "26-12-31".matches(regex): Returns false because the year portion only has 2 digits instead of the required 4.
• "2026/12/31".matches(regex): Returns false because the separators are forward slashes rather than the literal hyphens the pattern requires.

public class Main {
    public static void main(String[] args) {
        String regex = "([01]\\d|2[0-3]):[0-5]\\d";

        System.out.println("14:30".matches(regex));
        System.out.println("09:15".matches(regex));
        System.out.println("24:00".matches(regex));
        System.out.println("13:65".matches(regex));
    }
}Code language: Java (java)

Explanation:

• ([01]\\d|2[0-3]): A grouped alternative for the hour portion. The first branch, [01]\d, covers 00 through 19, and the second branch, 2[0-3], covers 20 through 23.
• :[0-5]\\d: Requires a literal colon, followed by minutes restricted to 00 through 59, since the first minute digit can only range from 0 to 5.
• "24:00".matches(regex): Returns false because 24 is not covered by either hour alternative, correctly rejecting an hour value that does not exist on a 24-hour clock.
• "13:65".matches(regex): Returns false because 65 is outside the valid 00–59 minute range, even though the hour portion, 13, is perfectly valid.

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

public class Main {
    public static void main(String[] args) {
        String regex = "https?://(?:www\\.)?([a-zA-Z0-9.-]+)";
        String url = "https://www.google.com/search";

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

        if (matcher.find()) {
            System.out.println("Domain: " + matcher.group(1));
        }
    }
}Code language: Java (java)

Explanation:

• https?://: Matches either http:// or https://, since the ? makes the preceding s optional.
• (?:www\\.)?: A non-capturing group, marked by ?:, that optionally matches a leading www. without that text becoming part of any captured group.
• ([a-zA-Z0-9.-]+): A capturing group, marked by plain parentheses, matching the actual domain name made of letters, digits, dots, and hyphens.
• matcher.group(1): Retrieves the text captured by the first parenthesized group, which is exactly the domain portion, separate from the protocol, the optional www., and the trailing /search path.

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

public class Main {
    public static void main(String[] args) {
        String regex = "\\b(\\w+)\\s+\\1\\b";
        String input = "The the movie was was great";

        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(input);

        while (matcher.find()) {
            System.out.println("Duplicate found: " + matcher.group(1));
        }
    }
}Code language: Java (java)

Explanation:

• (\\w+): Captures one or more word characters as the first group, representing whatever word is found first.
• \\1: A backreference to the first captured group, requiring the exact same text to appear again, not just any word.
• Pattern.CASE_INSENSITIVE: Lets "The" and "the" count as the same repeated word, even though they differ in capitalization.
• Two separate matches: find() locates "The the" first, then continues scanning from where that match ended and locates "was was" as a second, independent match.

public class Main {
    public static void main(String[] args) {
        String regex = "([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}";

        System.out.println("01:23:45:67:89:ab".matches(regex));
        System.out.println("A1-B2-C3-D4-E5-F6".matches(regex));
        System.out.println("01:23:45:67:89".matches(regex));
        System.out.println("01:23:45:67:89:gh".matches(regex));
    }
}Code language: Java (java)

Explanation:

• ([0-9A-Fa-f]{2}[:-]): A group matching exactly 2 hex digits followed by either a colon or a hyphen.
• {5}: Repeats that entire group exactly 5 times, accounting for the first 5 hex pairs and their trailing separators.
• [0-9A-Fa-f]{2}: Matches the final, sixth hex pair on its own, with no trailing separator required after it.
• "01:23:45:67:89:gh".matches(regex): Returns false because g and h are not valid hex digits, falling outside the 0-9A-Fa-f range.

public class Main {
    public static void main(String[] args) {
        String octet = "(25[0-5]|2[0-4]\\d|[01]?\\d?\\d)";
        String regex = octet + "\\." + octet + "\\." + octet + "\\." + octet;

        System.out.println("192.168.1.1".matches(regex));
        System.out.println("255.255.255.255".matches(regex));
        System.out.println("256.100.50.25".matches(regex));
        System.out.println("192.168.1".matches(regex));
    }
}Code language: Java (java)

Explanation:

• 25[0-5]: The first alternative in the octet pattern, covering 250 through 255.
• 2[0-4]\\d: The second alternative, covering 200 through 249.
• [01]?\\d?\\d: The third alternative, covering everything from 0 through 199, including single and double digit values.
• Building the full pattern in code: Concatenating the octet string four times with escaped dots keeps the final regex readable, avoiding a single massive, repeated block of near-identical alternation written out by hand.
• "256.100.50.25".matches(regex): Returns false because 256 exceeds the maximum valid octet value of 255, and none of the three alternatives accept it.

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

public class Main {
    public static void main(String[] args) {
        String regex = "\\(?(\\d{3})\\)?[-.\\s]?(\\d{3})[-.\\s]?(\\d{4})";

        String phone1 = "(123) 456-7890";
        String phone2 = "123-456-7890";

        Matcher matcher1 = Pattern.compile(regex).matcher(phone1);
        Matcher matcher2 = Pattern.compile(regex).matcher(phone2);

        if (matcher1.matches()) {
            System.out.println("Area: " + matcher1.group(1) + ", Prefix: " + matcher1.group(2) + ", Line: " + matcher1.group(3));
        }
        if (matcher2.matches()) {
            System.out.println("Area: " + matcher2.group(1) + ", Prefix: " + matcher2.group(2) + ", Line: " + matcher2.group(3));
        }
    }
}Code language: Java (java)

Explanation:

• \\(?(\\d{3})\\)?: Matches an optional opening parenthesis, then captures exactly 3 digits as the area code, then an optional closing parenthesis.
• [-.\\s]?: Matches an optional single separator character, either a hyphen, a dot, or any whitespace character, between each group of digits.
• (\\d{3}) and (\\d{4}): Capture the 3-digit prefix and the 4-digit line number as two more separate groups, following the same digits-then-optional-separator pattern.
• Same three groups, two formats: Both "(123) 456-7890" and "123-456-7890" produce identical captured groups, since the optional parentheses and flexible separator character class accommodate both styles with the same single pattern.

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

public class Main {
    public static void main(String[] args) {
        String regex = "<h1>(.*?)</h1>";
        String input = "<h1>Hello</h1>";

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

        if (matcher.find()) {
            System.out.println("Extracted text: " + matcher.group(1));
        }
    }
}Code language: Java (java)

Explanation:

• <h1> and </h1>: Matched literally, since angle brackets are not special regex characters and need no escaping.
• (.*?): A reluctant quantifier that captures as few characters as possible while still allowing the rest of the pattern, the closing tag, to match.
• matcher.group(1): Retrieves just the captured content between the two tags, excluding the tags themselves.
• Caution: This simple approach breaks down on nested or malformed HTML. For any real HTML parsing task, a dedicated HTML parser library is far more reliable than a hand-written regex.

public class Main {
    public static void main(String[] args) {
        String input = "camelCaseString";
        String regex = "(?<!^)(?=[A-Z])";

        String[] words = input.split(regex);
        System.out.println(String.join(" ", words));
    }
}Code language: Java (java)

Explanation:

• (?=[A-Z]): A positive lookahead marking every position in the string that is immediately followed by an uppercase letter, without consuming that letter.
• (?<!^): A negative lookbehind excluding the very start of the string, so if the input itself began with an uppercase letter, that position would not trigger an extra split.
• input.split(regex): Splits the string at each qualifying zero-width position, without consuming or removing any actual characters from the result.
• String.join(" ", words): Reassembles the resulting word array into a single space-separated string for display.

public class Main {
    public static void main(String[] args) {
        String regex = "\\s*,\\s*";
        String input = "Java, Python , C++,Kotlin";

        String[] values = input.split(regex);
        for (String value : values) {
            System.out.println("[" + value + "]");
        }
    }
}Code language: Java (java)

Explanation:

• \\s*,\\s*: Matches zero or more whitespace characters, then a literal comma, then zero or more whitespace characters again, treating the whole thing as one delimiter.
• input.split(regex): Breaks the string apart everywhere that delimiter pattern occurs, discarding the matched commas and surrounding spaces entirely.
• "Python " versus "Python": Without the surrounding \s*, splitting on a plain comma would leave a stray leading or trailing space on values like " Python ". The whitespace-aware delimiter avoids that entirely.
• Square brackets in the output: Added purely for display, to make any accidental leftover whitespace in a value immediately visible around its printed brackets.

public class Main {
    public static void main(String[] args) {
        String regex = "(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[^a-zA-Z0-9]).{8,}";

        System.out.println("Passw0rd!".matches(regex));
        System.out.println("password1".matches(regex));
        System.out.println("PASSWORD1!".matches(regex));
        System.out.println("Pw1!".matches(regex));
    }
}Code language: Java (java)

Explanation:

• (?=.*[a-z]): Requires a lowercase letter somewhere in the string, checked without moving the matching position forward.
• (?=.*[A-Z]) and (?=.*\\d): Similarly require an uppercase letter and a digit somewhere in the string, each as its own independent condition.
• (?=.*[^a-zA-Z0-9]): Requires at least one character that is not a letter or digit, covering punctuation and symbols as the “special character” requirement.
• .{8,}: The only part of the pattern that actually consumes characters, requiring the whole string to be at least 8 characters long once every lookahead condition has already passed.

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

public class Main {
    public static void main(String[] args) {
        String regex = "\\d+(?!\\d)(?!%)";
        String input = "Sales grew 20% while profit rose 15 points and revenue hit 100";

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

        while (matcher.find()) {
            System.out.println("Found: " + matcher.group());
        }
    }
}Code language: Java (java)

Explanation:

• \\d+: Greedily matches as many consecutive digits as possible at the current position.
• (?!\\d): Confirms the digit run truly ended here, meaning the next character is not another digit. This blocks the engine from backtracking to a shorter, incomplete number just to satisfy a later check.
• (?!%): Only now checks whether a percent sign immediately follows the complete number, rejecting the whole match if it does.
• Why 20 is skipped entirely, not partially matched: Since (?!\d) forces the engine to only consider the complete two-digit run, and that complete run is immediately followed by %, the entire match attempt at that position fails, rather than falling back to matching just 2.

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

public class Main {
    public static void main(String[] args) {
        String regex = "\\b(?!un)\\w+\\b";
        String input = "The unhappy user was unable to undo the untimely mistake";

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

        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }
}Code language: Java (java)

Explanation:

• \\b: Anchors the check to the start of a word, so the lookahead that follows only evaluates the first two characters of each word, not two characters found mid-word.
• (?!un): Rejects the position entirely if the next two characters spell un, ruling out unhappy, unable, undo, and untimely right at their starting boundary.
• \\w+\\b: Once a word survives the lookahead, this captures the rest of it, up through its own trailing word boundary.
• Words like "user": Pass the lookahead cleanly, since their first two characters are us, not un, even though the word starts with the same letter u the excluded words do.

public class Main {
    public static void main(String[] args) {
        String regex = "[-+]?\\d*\\.?\\d+([eE][-+]?\\d+)?";

        System.out.println("3.14".matches(regex));
        System.out.println("-0.5".matches(regex));
        System.out.println("6.022e23".matches(regex));
        System.out.println("abc".matches(regex));
    }
}Code language: Java (java)

Explanation:

• [-+]?: Matches an optional leading sign, covering both positive and negative numbers, as well as numbers written with no sign at all.
• \\d*\\.?\\d+: Matches an optional whole-number part, an optional decimal point, and a required final group of digits, covering both 3.14 and simpler whole numbers without a decimal point.
• ([eE][-+]?\\d+)?: An entirely optional group for scientific notation, matching an e or E, an optional sign, and one or more digits for the exponent.
• "6.022e23".matches(regex): Returns true, since the base number 6.022 is followed by a valid scientific notation suffix, e23, matching the optional final group.

public class Main {
    public static void main(String[] args) {
        String code = "int x = 5; /* this is a\nmulti-line comment */ int y = 10;";
        String regex = "(?s)/\\*.*?\\*/";

        String cleaned = code.replaceAll(regex, "").trim();
        System.out.println(cleaned);
    }
}Code language: Java (java)

Explanation:

• (?s): An inline flag enabling DOTALL mode, so the . in the pattern that follows also matches newline characters, not just ordinary characters.
• /\\*.*?\\*/: Matches a literal /*, then reluctantly consumes everything up to the first */ it encounters, correctly handling the embedded newline in the middle of the comment.
• code.replaceAll(regex, ""): Removes the entire matched comment, including its delimiters, replacing it with nothing.
• Leftover double space: The final .trim() only removes whitespace from the very start and end of the whole string. It does not collapse the double space left behind in the middle where the comment used to sit.

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

public class Main {
    public static void main(String[] args) {
        String regex = "([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+)\\.([a-zA-Z]{2,})";
        String email = "john.doe@example.com";

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

        if (matcher.matches()) {
            System.out.println("Username: " + matcher.group(1));
            System.out.println("Domain: " + matcher.group(2));
            System.out.println("TLD: " + matcher.group(3));
        }
    }
}Code language: Java (java)

Explanation:

• ([a-zA-Z0-9._%+-]+): The first capturing group, matching the username portion before the @ symbol, allowing letters, digits, and a handful of common punctuation characters.
• ([a-zA-Z0-9.-]+): The second capturing group, matching the domain portion, up to but not including the final dot before the TLD.
• \\.([a-zA-Z]{2,}): A literal dot followed by the third capturing group, requiring at least 2 letters for the TLD.
• matcher.group(1), group(2), group(3): Retrieve the three captured pieces independently, giving john.doe, example, and com as three separate values from one single validated match.

public class Main {
    public static void main(String[] args) {
        String number = "1000000";
        String regex = "(?<=\\d)(?=(\\d{3})+(?!\\d))";

        String formatted = number.replaceAll(regex, ",");
        System.out.println(formatted);
    }
}Code language: Java (java)

Explanation:

• (?<=\\d): A positive lookbehind requiring a digit immediately before the current position, ensuring commas are never inserted right at the very start of the number.
• (?=(\\d{3})+(?!\\d)): A positive lookahead requiring that everything remaining from this position to the end of the string forms one or more complete groups of exactly 3 digits, with the inner (?!\d) confirming there is no leftover partial group afterward.
• Zero-width match: Neither lookaround consumes any characters, so this pattern only ever matches an empty-width position, which replaceAll() then fills with a literal comma.
• "1000000" becoming "1,000,000": Commas are inserted after the 1st and 4th digits, since those are exactly the positions where a digit precedes them and the remaining digits still form complete groups of 3.