☕ Java

Java Regular Expressions (RegEx)

A complete guide to Java Regular Expressions — regex syntax (character classes, quantifiers, anchors, groups, lookahead, lookbehind), Pattern and Matcher API, all Matcher methods, regex flags, String regex methods, real-world validation patterns for email, phone, password, and URL, plus best practices with examples.

📅

Last Updated

March 2026

⏱️

Read Time

20 min

🎯

Level

Beginner to Intermediate

What is Regular Expression in Java?

A Regular Expression (regex or regexp) is a precisely defined sequence of characters that describes a search pattern. In Java, regular expressions are used to match, search, extract, validate, and replace text within strings — from simple substring checks to complex pattern matching across thousands of lines of input.

Java provides regex support through the java.util.regex package, which contains two core classes: Pattern (the compiled regex) and Matcher (the engine that applies the pattern to an input string). The String class also exposes four convenience methods — matches(), replaceAll(), replaceFirst(), and split() — that accept regex patterns directly.

Regular expressions are indispensable in real-world Java applications: validating user input (email, phone, password), parsing log files, sanitizing form data, extracting structured data from unstructured text, routing URLs in web frameworks, and tokenizing DSL syntax. Every Java developer at the professional level must be fluent in regex.

☕ JavaRegex — First Example

import java.util.regex.*;

public class RegexIntro {
    public static void main(String[] args) {

        String text = "Order #1042 placed on 2026-03-16 for ₹4500";

        // Find all numbers in the text
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher(text);

        System.out.println("Numbers found in text:");
        while (matcher.find()) {
            System.out.println("  '" + matcher.group() + "'  at index " + matcher.start());
        }
    }
}

Output

Numbers found in text: '1042' at index 7 '2026' at index 22 '03' at index 27 '16' at index 30 '4500' at index 37

Regex Syntax — Complete Quick Reference

Every regex is built from a small set of syntax elements. The table below is your complete reference for all Java regex syntax — bookmark it.

Token	Meaning	Example Pattern	Matches
.	Any single character except newline (by default)	a.c	abc, aXc, a1c
\d	Any digit [0-9]	\d\d\d	123, 456, 007
\D	Any non-digit	\D+	abc, !, Hello
\w	Word character [a-zA-Z0-9_]	\w+	hello, Java_8, test123
\W	Non-word character	\W+	, !@#, ...
\s	Whitespace (space, tab, newline)	\s+	' ', '\t', '\n'
\S	Non-whitespace	\S+	hello, 123, !
^	Start of string (or line with MULTILINE flag)	^Hello	Matches 'Hello' only at start
$	End of string (or line with MULTILINE flag)	world$	Matches 'world' only at end
\b	Word boundary	\bcat\b	Matches 'cat' not 'catch' or 'scat'
\B	Non-word boundary	\Bcat\B	Matches 'cat' inside 'scat' or 'catch'
[abc]	Character class — any one of a, b, c	[aeiou]	Matches any single vowel
[^abc]	Negated class — any character NOT in set	[^0-9]	Any non-digit
[a-z]	Range — any char from a to z	[a-zA-Z]	Any English letter
(abc)	Capturing group	(\d{4})	Captures a 4-digit year
(?:abc)	Non-capturing group	(?:https?://)	Groups without capturing
(?<name>abc)	Named capturing group	(?<year>\d{4})	Named capture 'year'
a\|b	Alternation — a or b	cat\|dog	Matches 'cat' or 'dog'
\	Escape special character	\.	Literal dot, not 'any char'
(?i)	Inline flag — case insensitive	(?i)hello	Matches HELLO, Hello, hello
(?=...)	Positive lookahead	\d+(?= dollars)	Digits followed by ' dollars'
(?!...)	Negative lookahead	\d+(?! dollars)	Digits NOT followed by ' dollars'
(?<=...)	Positive lookbehind	(?<=₹)\d+	Digits preceded by '₹'
(?<!...)	Negative lookbehind	(?<!₹)\d+	Digits NOT preceded by '₹'
\1	Backreference to group 1	(\w+) \1	Repeated word: 'hello hello'

Character Classes — Matching Sets of Characters

Character classes define a set of characters that a single position in the input can match. They are enclosed in square brackets [] and give you fine-grained control over which characters are acceptable at a given position.

☕ JavaCharacter Classes — All Variants

import java.util.regex.*;

public class CharacterClassDemo {
    public static void main(String[] args) {

        // Simple class — any one of these characters
        print("[aeiou]",      "elephant"); // e, e, a

        // Negated class — anything NOT in this set
        print("[^aeiou\\s]", "Hello World"); // H,l,l,W,r,l,d

        // Range — a through z
        print("[a-z]+",        "Hello123World"); // ello, orld

        // Union of classes — letter OR digit
        print("[a-zA-Z0-9]+",  "Hi! I am R2D2."); // Hi, I, am, R2D2

        // Intersection — letter AND NOT vowel (consonants only)
        // Uses && inside [] for intersection
        print("[a-z&&[^aeiou]]+", "programming"); // prgrmmng

        // Predefined shorthand classes
        print("\\d+",  "Room 404 on Floor 2");  // 404, 2
        print("\\w+",  "Hello, World! 2026");   // Hello, World, 2026
        print("\\s+",  "one two\tthree");       // ' ', '\t'
    }

    static void print(String regex, String input) {
        Matcher m = Pattern.compile(regex).matcher(input);
        System.out.print("Regex [" + regex + "] → ");
        while (m.find()) System.out.print("'" + m.group() + "' ");
        System.out.println();
    }
}

Output

Regex [[aeiou]] → 'e' 'e' 'a' Regex [[^aeiou\s]] → 'H' 'l' 'l' 'W' 'r' 'l' 'd' Regex [[a-z]+] → 'ello' 'orld' Regex [[a-zA-Z0-9]+] → 'Hi' 'I' 'am' 'R2D2' Regex [[a-z&&[^aeiou]]+] → 'prgrmmng' Regex [\d+] → '404' '2' Regex [\w+] → 'Hello' 'World' '2026' Regex [\s+] → ' ' '\t'

Quantifiers — Controlling Repetition

Quantifiers specify how many times the preceding element must appear for a match. Java supports three flavors of every quantifier: greedy (default — matches as much as possible), reluctant/lazy (matches as little as possible, add ?), and possessive (matches as much as possible, never backtracks, add +).

Quantifier	Greedy	Reluctant (Lazy)	Possessive	Meaning
Zero or one	?	??	?+	Optional — 0 or 1 occurrence
Zero or more	*	*?	*+	Any number including none
One or more	+	+?	++	At least one occurrence
Exactly n	{n}	{n}?	{n}+	Exactly n occurrences
n or more	{n,}	{n,}?	{n,}+	At least n occurrences
Between n and m	{n,m}	{n,m}?	{n,m}+	Between n and m occurrences (inclusive)

☕ JavaGreedy vs Lazy Quantifiers — Critical Difference

import java.util.regex.*;

public class QuantifierDemo {
    public static void main(String[] args) {

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

        // GREEDY — matches from FIRST < to LAST > (too much)
        Matcher greedy = Pattern.compile("<.+>").matcher(html);
        if (greedy.find()) {
            System.out.println("Greedy:   '" + greedy.group() + "'");
        }
        // Output: '<b>bold</b> and <i>italic</i>'

        // LAZY — matches from FIRST < to NEAREST > (correct for HTML tags)
        Matcher lazy = Pattern.compile("<.+?>").matcher(html);
        System.out.print("Lazy:     ");
        while (lazy.find()) {
            System.out.print("'" + lazy.group() + "' ");
        }
        System.out.println();
        // Output: '<b>' '</b>' '<i>' '</i>'

        // Exact quantifiers
        String pins = "PIN: 1234, invalid: 56789, ok: 9876";
        Matcher fourDigit = Pattern.compile("\\b\\d{4}\\b").matcher(pins);
        System.out.print("4-digit PINs: ");
        while (fourDigit.find()) {
            System.out.print("'" + fourDigit.group() + "' ");
        }
        // Output: '1234' '9876'  (56789 has 5 digits — not matched)
    }
}

Output

Greedy: 'bold and italic' Lazy: '' '' '' '' 4-digit PINs: '1234' '9876'

Anchors and Word Boundaries

Anchors match a position in the string — not a character. They are zero-width assertions: they consume no characters but constrain where in the string a match can occur.

☕ JavaAnchors and Boundaries — Practical Examples

import java.util.regex.*;

public class AnchorDemo {
    public static void main(String[] args) {

        // ^ — match only at start of string
        System.out.println("ERROR: fail".matches("^ERROR.*"));  // true
        System.out.println("INFO: ERROR".matches("^ERROR.*"));  // false

        // $ — match only at end of string
        System.out.println("image.png".matches(".*\\.png$"));  // true
        System.out.println("image.png.bak".matches(".*\\.png$")); // false

        // \b — word boundary: matches where a word starts or ends
        String text = "The cat scattered the catalog";
        Matcher wb = Pattern.compile("\\bcat\\b").matcher(text);
        System.out.print("\\bcat\\b matches: ");
        while (wb.find()) System.out.print("'" + wb.group() + "'@" + wb.start() + " ");
        // Only 'cat' at position 4 — not 'cat' inside 'scattered' or 'catalog'

        System.out.println();

        // \A and \Z — absolute start/end (unaffected by MULTILINE flag)
        String multiLine = "first line\nsecond line\nthird line";
        Matcher absStart = Pattern.compile("\\Afirst").matcher(multiLine);
        System.out.println("\\Afirst found: " + absStart.find()); // true

        // MULTILINE flag changes ^ and $ to match per line
        Matcher perLine = Pattern.compile("^second",
            Pattern.MULTILINE).matcher(multiLine);
        System.out.println("^second with MULTILINE: " + perLine.find()); // true
    }
}

Output

true false true false \bcat\b matches: 'cat'@4 \Afirst found: true ^second with MULTILINE: true

Groups and Backreferences

Groups serve two purposes in regex: they can group tokens together (apply a quantifier to multiple characters) and they can capture the matched text for later retrieval or backreference. Java supports numbered groups, named groups, and non-capturing groups.

☕ JavaCapturing Groups, Named Groups, and Backreferences

import java.util.regex.*;

public class GroupDemo {
    public static void main(String[] args) {

        // ── NUMBERED GROUPS ─────────────────────────────────────────────
        // Pattern: (yyyy)-(MM)-(dd) — three capturing groups
        String dateStr = "Invoice date: 2026-03-16, Due: 2026-04-15";
        Pattern datePattern = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
        Matcher m = datePattern.matcher(dateStr);

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

        // ── NAMED GROUPS ────────────────────────────────────────────────
        Pattern named = Pattern.compile(
            "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})");
        Matcher mn = named.matcher("2026-03-16");
        if (mn.matches()) {
            System.out.println("Named year : " + mn.group("year"));
            System.out.println("Named month: " + mn.group("month"));
        }

        // ── NON-CAPTURING GROUP (?:) ─────────────────────────────────────
        // Groups without capturing — saves memory, avoids polluting group numbers
        Pattern proto = Pattern.compile("(?:https?|ftp)://([\\w./-]+)");
        Matcher mp = proto.matcher("Visit https://techsustainify.com/java");
        if (mp.find()) {
            System.out.println("Host+path  : " + mp.group(1)); // group 1 = after ://
        }

        // ── BACKREFERENCE \1 ─────────────────────────────────────────────
        // Match a repeated word (e.g., typo detection)
        Pattern dupe = Pattern.compile("\\b(\\w+)\\s+\\1\\b");
        Matcher md = dupe.matcher("The the quick brown fox fox jumps");
        System.out.print("Duplicate words: ");
        while (md.find()) {
            System.out.print("'" + md.group(1) + "' ");
        }
        System.out.println();
    }
}

Output

Full match : 2026-03-16 Year : 2026 Month : 03 Day : 16 --- Full match : 2026-04-15 Year : 2026 Month : 04 Day : 15 --- Named year : 2026 Named month: 03 Host+path : techsustainify.com/java Duplicate words: 'The' 'fox'

Lookahead and Lookbehind — Zero-Width Assertions

Lookahead and Lookbehind are zero-width assertions — they check the context around a position without consuming characters. The matched text of the lookahead/lookbehind itself is not included in the match result. This makes them ideal for asserting surrounding context without capturing it.

Assertion	Syntax	Meaning	Example
Positive Lookahead	(?=...)	What follows MUST match	\d+(?=px) — digits followed by 'px'
Negative Lookahead	(?!...)	What follows must NOT match	\d+(?!px) — digits NOT followed by 'px'
Positive Lookbehind	(?<=...)	What precedes MUST match	(?<=₹)\d+ — digits preceded by '₹'
Negative Lookbehind	(?<!...)	What precedes must NOT match	(?<!-)\d+ — digits NOT preceded by '-'

☕ JavaLookahead and Lookbehind — Real-World Examples

import java.util.regex.*;

public class LookaroundDemo {
    public static void main(String[] args) {

        // ── POSITIVE LOOKAHEAD (?=...) ──────────────────────────────────
        // Extract numbers that are followed by 'px' (CSS values)
        String css = "margin: 16px; padding: 8px; border: 1em; font: 14px;";
        Matcher la = Pattern.compile("\\d+(?=px)").matcher(css);
        System.out.print("px values: ");
        while (la.find()) System.out.print(la.group() + " ");
        // Output: 16 8 14  (1em is excluded)

        System.out.println();

        // ── NEGATIVE LOOKAHEAD (?!...) ──────────────────────────────────
        // Find numbers NOT followed by 'px'
        Matcher nla = Pattern.compile("\\d+(?!px)\\b").matcher(css);
        System.out.print("non-px values: ");
        while (nla.find()) System.out.print(nla.group() + " ");
        // Output: 1  (from '1em')

        System.out.println();

        // ── POSITIVE LOOKBEHIND (?<=...) ────────────────────────────────
        // Extract amounts after currency symbol
        String receipt = "Total: ₹1500, Discount: ₹200, Payable: ₹1300";
        Matcher lb = Pattern.compile("(?<=₹)\\d+").matcher(receipt);
        System.out.print("Amounts: ");
        while (lb.find()) System.out.print(lb.group() + " ");
        // Output: 1500 200 1300

        System.out.println();

        // ── NEGATIVE LOOKBEHIND (?<!...) ────────────────────────────────
        // Match numbers NOT preceded by '#' (not hex codes)
        String colors = "color: #FF5733; opacity: 0.8; z-index: 10";
        Matcher nlb = Pattern.compile("(?<!#)\\b\\d+\\.?\\d*\\b").matcher(colors);
        System.out.print("Non-hex numbers: ");
        while (nlb.find()) System.out.print(nlb.group() + " ");
        // Output: 0.8 10
    }
}

Output

px values: 16 8 14 non-px values: 1 Amounts: 1500 200 1300 Non-hex numbers: 0.8 10

Pattern and Matcher Classes — The Core API

The java.util.regex.Pattern class represents a compiled regular expression. Compilation parses the regex string into an internal finite automaton — this is expensive. java.util.regex.Matcher is the engine that applies a compiled Pattern to a specific input string.

☕ JavaPattern and Matcher — Full API Walkthrough

import java.util.regex.*;
import java.util.*;

public class PatternMatcherAPI {
    public static void main(String[] args) {

        // ── CREATING A PATTERN ───────────────────────────────────────────
        // compile() — parse once, reuse many times
        Pattern emailPattern = Pattern.compile(
            "[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}");

        // ── CREATING A MATCHER ───────────────────────────────────────────
        String input = "Contact: rahul@techsustainify.com or support@example.org";
        Matcher m = emailPattern.matcher(input);

        // ── find() — locate next match ───────────────────────────────────
        List<String> emails = new ArrayList<>();
        while (m.find()) {
            emails.add(m.group());
        }
        System.out.println("Emails: " + emails);

        // ── Reset matcher for a new input (avoid recompiling Pattern) ───
        String input2 = "admin@company.in";
        m.reset(input2);
        System.out.println("Valid email: " + m.matches());

        // ── matches() — entire string must match ─────────────────────────
        System.out.println("not-valid@".matches(
            "[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}")); // false

        // ── start() end() group() — position and text ────────────────────
        Matcher pos = Pattern.compile("\\d{4}").matcher("Year 2026 and 2027");
        while (pos.find()) {
            System.out.printf("Found '%s' at [%d, %d)%n",
                pos.group(), pos.start(), pos.end());
        }

        // ── Pattern.split() — split by regex ─────────────────────────────
        String csv = "Java,,Python,  ,Go,Rust";
        String[] parts = Pattern.compile(",\\s*,?").split(csv);
        System.out.println(Arrays.toString(parts));

        // ── Pattern.quote() — escape a literal string for regex ──────────
        String literal = "3.14";  // dot means 'any char' in regex
        String safe = Pattern.quote(literal); // \Q3.14\E
        System.out.println("3X14".matches(safe)); // false — literal dot only
        System.out.println("3.14".matches(safe)); // true
    }
}

Output

Emails: [rahul@techsustainify.com, support@example.org] Valid email: true false Found '2026' at [5, 9) Found '2027' at [14, 18) [Java, Python, Go, Rust] false true

Matcher Methods — Complete Reference

The Matcher class is the workhorse of Java regex. Every useful operation — finding, extracting, replacing, and positioning — goes through these methods.

Method	Description	Returns
find()	Scans input for the next subsequence matching the pattern	boolean — true if a match is found
find(int start)	Resets the matcher and starts searching from the given index	boolean
matches()	Attempts to match the ENTIRE input against the pattern	boolean — true only if full input matches
lookingAt()	Attempts to match from the BEGINNING of the input (prefix match — tail need not match)	boolean
group()	Returns the text matched by the most recent find()/matches() call	String — the matched substring
group(int n)	Returns the text captured by group number n (1-indexed; 0 = full match)	String — captured group text
group(String name)	Returns the text captured by a named group (?<name>...)	String — named group text
groupCount()	Returns the total number of capturing groups in the pattern	int
start()	Returns the start index of the last match in the input	int
start(int n)	Returns the start index of capturing group n	int
end()	Returns the index AFTER the last character of the match	int
end(int n)	Returns the end index of capturing group n	int
replaceAll(String replacement)	Replaces every match with the replacement string	String — new string with all replacements
replaceFirst(String replacement)	Replaces only the first match with the replacement string	String — new string with first replacement
appendReplacement(StringBuffer sb, String replacement)	Appends the text up to the current match and the replacement into sb — used for custom replacements in a loop	Matcher (for chaining)
appendTail(StringBuffer sb)	Appends the remainder of the input (after last match) into sb	StringBuffer
reset()	Resets matcher to the beginning of the current input	Matcher
reset(CharSequence input)	Resets matcher with a new input string (avoids recompiling Pattern)	Matcher
usePattern(Pattern newPattern)	Changes the Pattern this Matcher uses	Matcher
region(int start, int end)	Limits the region of input to be searched	Matcher
hitEnd()	Returns true if the end of the input was reached during the last match	boolean
requireEnd()	Returns true if more input might change a positive match into a negative one	boolean

Regex Flags — Modifying Match Behavior

Regex flags modify how the matching engine interprets both the pattern and the input. They can be passed to Pattern.compile(regex, flags) or embedded directly in the pattern using inline flag syntax (?flag).

Flag Constant	Inline Syntax	Effect
Pattern.CASE_INSENSITIVE	(?i)	Case-insensitive matching for ASCII characters. 'Hello' matches 'hello', 'HELLO', 'HeLLo'.
Pattern.MULTILINE	(?m)	^ and $ match at the start/end of each LINE rather than the whole input. Essential for processing multi-line text.
Pattern.DOTALL	(?s)	The dot (.) matches ANY character including newline '\n'. Without this flag, dot does not match newlines.
Pattern.UNICODE_CASE	(?u)	Combined with CASE_INSENSITIVE, enables Unicode-aware case folding. 'ü' matches 'Ü'.
Pattern.UNICODE_CHARACTER_CLASS	(?U)	Makes \d, \w, \s Unicode-aware. \d matches all Unicode digits, not just [0-9].
Pattern.COMMENTS	(?x)	Whitespace and # comments are ignored in the pattern. Allows writing readable, documented regex across multiple lines.
Pattern.LITERAL	(none)	The entire pattern is treated as a literal string — all metacharacters are escaped automatically. Equivalent to Pattern.quote().
Pattern.CANON_EQ	(none)	Two characters match if their full canonical decomposition matches. Handles Unicode combining characters.

☕ JavaRegex Flags — Practical Examples

import java.util.regex.*;

public class RegexFlagsDemo {
    public static void main(String[] args) {

        // CASE_INSENSITIVE — flag constant
        Pattern ci = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
        System.out.println(ci.matcher("I love JAVA!").find()); // true

        // CASE_INSENSITIVE — inline (?i)
        System.out.println("HELLO".matches("(?i)hello")); // true

        // MULTILINE — ^ matches start of each line
        String log = "INFO: Server started\nERROR: DB failed\nINFO: Retry";
        Matcher ml = Pattern.compile("^ERROR.*", Pattern.MULTILINE).matcher(log);
        System.out.println("ERROR lines:");
        while (ml.find()) System.out.println("  " + ml.group());

        // DOTALL — dot matches newline too
        String multiLine = "START\nMIDDLE\nEND";
        System.out.println(multiLine.matches("START.*END"));         // false — dot skips \n
        System.out.println(multiLine.matches("(?s)START.*END"));     // true  — (?s) enables DOTALL

        // COMMENTS — write readable regex with whitespace and comments
        Pattern readable = Pattern.compile(
            "([a-zA-Z0-9._%+\\-]+)  # local part\n" +
            "@                        # at sign\n" +
            "([a-zA-Z0-9.\\-]+)       # domain\n" +
            "\\.([a-zA-Z]{2,})         # TLD",
            Pattern.COMMENTS);
        System.out.println(readable.matcher("dev@techsustainify.com").matches()); // true

        // Multiple flags combined with bitwise OR
        Pattern multi = Pattern.compile("^error",
            Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
        System.out.println(multi.matcher("INFO\nERROR: crash").find()); // true
    }
}

Output

true true ERROR lines: ERROR: DB failed false true true true

String Class Regex Methods

The String class provides four built-in regex convenience methods that internally use Pattern and Matcher. They are ideal for one-off regex operations, but compile the pattern on every call — so use Pattern.compile() directly for performance-critical or frequently-called code.

☕ JavaString Regex Methods — matches, replaceAll, replaceFirst, split

public class StringRegexMethods {
    public static void main(String[] args) {

        // ── matches(regex) ───────────────────────────────────────────────
        // Equivalent to Pattern.compile(regex).matcher(str).matches()
        // ENTIRE string must match the pattern
        String phone = "9876543210";
        System.out.println(phone.matches("[6-9]\\d{9}"));  // true — valid Indian mobile
        System.out.println("123456".matches("[6-9]\\d{9}")); // false

        // ── replaceAll(regex, replacement) ───────────────────────────────
        // Replaces ALL occurrences matching the pattern
        String dirty = "  Hello    World   ";
        System.out.println(dirty.replaceAll("\\s+", " ").trim()); // 'Hello World'

        // Replace non-alphanumeric chars with underscore
        String filename = "my file (2026).txt";
        System.out.println(filename.replaceAll("[^a-zA-Z0-9.]", "_")); // my_file__2026_.txt

        // ── replaceFirst(regex, replacement) ─────────────────────────────
        // Replaces only the FIRST occurrence
        String text = "Error on line 42. Error on line 87.";
        System.out.println(text.replaceFirst("Error", "WARNING")); 
        // 'WARNING on line 42. Error on line 87.'

        // ── split(regex) ─────────────────────────────────────────────────
        // Split by any whitespace sequence
        String sentence = "Java  is   awesome";
        String[] words = sentence.split("\\s+");
        System.out.println(java.util.Arrays.toString(words)); // [Java, is, awesome]

        // Split by comma and optional surrounding spaces
        String csv = "Alice, Bob ,  Carol,Dave";
        String[] names = csv.split("\\s*,\\s*");
        System.out.println(java.util.Arrays.toString(names)); // [Alice, Bob, Carol, Dave]

        // Split with limit — keep at most N tokens
        String path = "com.techsustainify.java.regex";
        String[] parts = path.split("\\.", 2); // limit=2
        System.out.println(java.util.Arrays.toString(parts)); // [com, techsustainify.java.regex]
    }
}

Output

true false Hello World my_file__2026_.txt WARNING on line 42. Error on line 87. [Java, is, awesome] [Alice, Bob, Carol, Dave] [com, techsustainify.java.regex]

Regex Matching Flow — Flowchart

The flowchart below shows the complete execution path from writing a regex pattern to obtaining a match result through the Pattern/Matcher API.

📝 Write Regex PatternString pattern = "\\d{4}"

⚙️ Pattern.compile()Parses + compiles to NFA/DFA

❓ Syntax valid?

Invalid

💥 PatternSyntaxExceptionInvalid regex syntax

🔗 pattern.matcher(input)Creates Matcher for input string

❓ find() or matches()?Choose operation

find()

🔍 find()Search for next substring match

✅ matches()Full string must match

❓ Match found?

Yes

📤 group() / start() / end()Extract match text and position

find() loop

↩️ find() again?Continue for next match

🔚 No more matchesfind() returns false

Code Execution Flow — from source to output

Real-World Validation Patterns

Here are battle-tested, production-ready regex patterns for the most common Java validation scenarios. Each pattern is explained token by token.

Use Case	Regex Pattern	Explanation
Indian Mobile Number	^[6-9]\d{9}$	Starts with 6-9 (valid Indian prefixes), followed by exactly 9 more digits
Email Address	^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$	local@domain.tld — local part, @, domain, dot, TLD of 2+ letters
Strong Password	^(?=.[a-z])(?=.[A-Z])(?=.\d)(?=.[@$!%?&])[A-Za-z\d@$!%?&]{8,}$	Min 8 chars, must have lowercase, uppercase, digit, and special character — using lookaheads
IPv4 Address	^((25[0-5]\|2[0-4]\d\|[01]?\d\d?)\.){3}(25[0-5]\|2[0-4]\d\|[01]?\d\d?)$	Each octet is 0-255, four octets separated by dots
Date (YYYY-MM-DD)	^\d{4}-(0[1-9]\|1[0-2])-(0[1-9]\|[12]\d\|3[01])$	Year 4 digits, month 01-12, day 01-31
URL (http/https)	^https?://[\w\-]+(\.[\w\-]+)+([\w.,@?^=%&:/~+#\-]*[\w@?^=%&/~+#\-])?$	Optional https, domain with dots, optional path/query
Indian PIN Code	^[1-9][0-9]{5}$	6-digit code, first digit non-zero
PAN Card Number	^[A-Z]{5}[0-9]{4}[A-Z]$	5 uppercase letters, 4 digits, 1 uppercase letter
Credit Card (Visa)	^4[0-9]{12}(?:[0-9]{3})?$	Starts with 4, followed by 12 digits, optional 3 more (13 or 16 digits)
Hex Color Code	^#([A-Fa-f0-9]{6}\|[A-Fa-f0-9]{3})$	# followed by 3 or 6 hex digits
Username	^[a-zA-Z0-9_]{3,20}$	3-20 alphanumeric characters or underscore only
HTML Tag	<([a-zA-Z][a-zA-Z0-9])\b[^>]>(.*?)</\1>	Opening tag, content, closing tag matching via backreference \1

☕ JavaReal-World Patterns — Compiled as static final for Performance

import java.util.regex.*;

public class Validators {

    // ✅ Compile ONCE as static final — never recompile in methods
    private static final Pattern MOBILE =
        Pattern.compile("^[6-9]\\d{9}$");

    private static final Pattern EMAIL =
        Pattern.compile("^[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}$");

    private static final Pattern PASSWORD =
        Pattern.compile(
            "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]{8,}$");

    private static final Pattern PAN =
        Pattern.compile("^[A-Z]{5}[0-9]{4}[A-Z]$");

    public static boolean isValidMobile(String s)   { return MOBILE.matcher(s).matches(); }
    public static boolean isValidEmail(String s)    { return EMAIL.matcher(s).matches(); }
    public static boolean isStrongPassword(String s){ return PASSWORD.matcher(s).matches(); }
    public static boolean isValidPAN(String s)      { return PAN.matcher(s).matches(); }

    public static void main(String[] args) {
        System.out.println(isValidMobile("9876543210"));   // true
        System.out.println(isValidMobile("1234567890"));   // false
        System.out.println(isValidEmail("dev@tech.com"));  // true
        System.out.println(isValidEmail("bad@"));          // false
        System.out.println(isStrongPassword("Secure@123")); // true
        System.out.println(isStrongPassword("weak"));       // false
        System.out.println(isValidPAN("ABCDE1234F"));     // true
        System.out.println(isValidPAN("abcde1234f"));     // false
    }
}

Output

true false true false true false true false

Best Practices for Java Regular Expressions

Regex is powerful but can be slow, unmaintainable, or incorrect when misused. Following these best practices will save you from the most common regex pitfalls.

▶
✅ 1. Compile Pattern Once as static final — Pattern.compile() is expensive. Calling it inside a frequently-executed method or loop wastes CPU. Declare Pattern as a private static final field so it is compiled exactly once when the class loads. This is the single most impactful regex performance optimization in Java.
▶
✅ 2. Use Pattern.quote() for Literal Strings — When you need to match a literal string that may contain regex metacharacters (., *, +, ?, etc.), always wrap it with Pattern.quote(literal). This generates a \Q...\E escaped pattern that treats every character literally — preventing subtle bugs where a dot matches any character instead of a literal period.
▶
✅ 3. Prefer Non-Capturing Groups (?:) Over Capturing Groups — If you only need a group for quantifier application (not for extracting text), use (?:...) instead of (...). Non-capturing groups consume no memory for group capture and keep group numbering clean, making patterns with many groups easier to maintain.
▶
✅ 4. Use Lazy Quantifiers for HTML/XML Parsing — When parsing tag-delimited content, always use lazy quantifiers (.+? instead of .+). Greedy matching will consume from the first opening delimiter to the LAST closing delimiter in the string — almost never what you want. Use +? or *? to match the shortest possible token.
▶
✅ 5. Anchor Validation Patterns with ^ and $ — For input validation (email, phone, password), always anchor your pattern with ^ at the start and $ at the end. Without anchors, a pattern like \d+ would match any string containing a digit — including 'hello123world' — rather than rejecting it. Use \A and \Z for absolute anchors unaffected by the MULTILINE flag.
▶
✅ 6. Name Groups When Using More Than 2 — With more than two capturing groups, use named groups (?<name>...) and access them via group("name"). This makes complex patterns self-documenting and protects code from breaking when groups are added or reordered.
▶
✅ 7. Use COMMENTS Flag for Complex Patterns — For any pattern longer than 40 characters, use Pattern.COMMENTS to split it across lines with inline # comments. A well-commented 8-line regex is infinitely easier to maintain than a single-line monster string.
▶
❌ 8. Never Use Regex for Full HTML/XML Parsing — Regex cannot correctly parse nested or malformed HTML/XML. Use a proper DOM parser (jsoup, javax.xml) instead. Regex is appropriate only for extracting specific, well-defined patterns from HTML — not for parsing its structure.
▶
❌ 9. Beware of Catastrophic Backtracking — Patterns like (a+)+ or (.*)(.*) on long strings can cause exponential backtracking, freezing the JVM for minutes or crashing with a stack overflow. Avoid nested quantifiers on the same character class. Use possessive quantifiers (++) or atomic groups (?>...) where backtracking is unnecessary.

Real-World Code Examples

Example 1 — Log File Analyzer with Regex

☕ JavaParsing Apache-Style Access Logs with Regex

import java.util.regex.*;
import java.util.*;

public class LogAnalyzer {

    // Apache Combined Log Format pattern
    // 127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] "GET /index.html HTTP/1.1" 200 2326
    private static final Pattern LOG_PATTERN = Pattern.compile(
        "(?<ip>\\d{1,3}(?:\\.\\d{1,3}){3})" +  // IP address
        " \\S+ \\S+ " +                           // ident and user
        "\\[(?<datetime>[^\\]]+)\\] " +          // datetime
        "\"(?<method>\\w+) (?<path>\\S+)[^\"]*\"" + // request line
        " (?<status>\\d{3})" +                     // HTTP status
        " (?<bytes>\\d+|-)");                       // bytes sent

    public static void main(String[] args) {
        String[] logs = {
            "192.168.1.1 - alice [16/Mar/2026:10:00:01 +0530] \"GET /home HTTP/1.1\" 200 1523",
            "10.0.0.2 - bob [16/Mar/2026:10:00:45 +0530] \"POST /api/login HTTP/1.1\" 401 98",
            "192.168.1.5 - carol [16/Mar/2026:10:01:02 +0530] \"GET /dashboard HTTP/1.1\" 200 4096",
            "172.16.0.9 - dave [16/Mar/2026:10:01:30 +0530] \"GET /missing HTTP/1.1\" 404 512"
        };

        Map<String, Integer> statusCount = new LinkedHashMap<>();
        int totalBytes = 0;

        for (String log : logs) {
            Matcher m = LOG_PATTERN.matcher(log);
            if (m.find()) {
                String ip     = m.group("ip");
                String method = m.group("method");
                String path   = m.group("path");
                String status = m.group("status");
                String bytes  = m.group("bytes");

                statusCount.merge(status, 1, Integer::sum);
                if (!bytes.equals("-")) totalBytes += Integer.parseInt(bytes);

                System.out.printf("%-15s %-6s %-20s %s%n", ip, method, path, status);
            }
        }

        System.out.println("\nStatus summary: " + statusCount);
        System.out.println("Total bytes served: " + totalBytes);
    }
}

Output

192.168.1.1 GET /home 200 10.0.0.2 POST /api/login 401 192.168.1.5 GET /dashboard 200 172.16.0.9 GET /missing 404 Status summary: {200=2, 401=1, 404=1} Total bytes served: 6229

Example 2 — Custom Template Engine with Regex Replacement

☕ JavaSimple Regex-Based Template Engine

import java.util.regex.*;
import java.util.*;

public class TemplateEngine {

    // Matches {{variableName}} placeholders
    private static final Pattern PLACEHOLDER = Pattern.compile("\\{\\{(\\w+)\\}\\}");

    public static String render(String template, Map<String, String> context) {
        Matcher m = PLACEHOLDER.matcher(template);
        StringBuffer sb = new StringBuffer();

        while (m.find()) {
            String key         = m.group(1);          // captured variable name
            String replacement = context.getOrDefault(key, "{{" + key + "}}");
            m.appendReplacement(sb, Matcher.quoteReplacement(replacement));
        }
        m.appendTail(sb);
        return sb.toString();
    }

    public static void main(String[] args) {
        String emailTemplate =
            "Dear {{name}},\n" +
            "Your order #{{orderId}} of ₹{{amount}} has been confirmed.\n" +
            "Expected delivery: {{deliveryDate}}.\n" +
            "Thank you for shopping with {{storeName}}!";

        Map<String, String> data = new LinkedHashMap<>();
        data.put("name",         "Rahul Sharma");
        data.put("orderId",      "ORD-20260316-4821");
        data.put("amount",       "3,499");
        data.put("deliveryDate", "19 March 2026");
        data.put("storeName",    "TechStore India");

        System.out.println(render(emailTemplate, data));
    }
}

Output

Dear Rahul Sharma, Your order #ORD-20260316-4821 of ₹3,499 has been confirmed. Expected delivery: 19 March 2026. Thank you for shopping with TechStore India!

Practice This Code — Live Editor

Advantages and Disadvantages of Regular Expressions

Regular expressions are one of the most powerful text-processing tools available. Like any powerful tool, they can be misused. Understanding both sides helps you decide when regex is the right choice.

✅ Advantages

Extremely Concise for Complex Text PatternsA single regex like ^(?=.*[A-Z])(?=.*\d).{8,}$ enforces complex password rules in one line. The equivalent imperative Java code would require 10-15 lines of character-by-character checks.

Universal — Works Across Languages and ToolsRegex syntax is largely portable across Java, Python, JavaScript, grep, sed, awk, and most IDEs. Skills learned for Java regex apply directly to log analysis, shell scripting, and text editors.

High Performance for Pattern MatchingThe Java regex engine compiles patterns to efficient NFAs. For repeated matching with pre-compiled Patterns, Java regex outperforms equivalent hand-written string manipulation in both speed and maintainability.

Rich Extraction CapabilitiesNamed and numbered capturing groups allow structured data extraction from unstructured text in a single pass — dates, IPs, currencies, email addresses — without splitting or manual indexing.

Built into String and Streams APIThe String.matches(), split(), replaceAll() methods and Stream filter/map operations accept lambdas that use regex — enabling clean, declarative data pipelines without verbose loop constructs.

Flexible Pattern CompositionLookahead, lookbehind, backreferences, and alternation allow expressing constraints that would require multiple method calls in plain Java — like 'digits preceded by a currency symbol but not inside a hex color code'.

❌ Disadvantages

Readability Degrades Sharply with ComplexityA 60-character validation regex is nearly unreadable without comments. Maintenance by a team member unfamiliar with regex syntax becomes risky — small edits can silently break the pattern.

Catastrophic Backtracking RiskPoorly written patterns with ambiguous quantifiers — particularly nested repetition like (a+)+ — can cause exponential time complexity on adversarial input. This is a real security vulnerability (ReDoS — Regular Expression Denial of Service) in web applications.

Not Suitable for Recursive or Nested StructuresRegular expressions cannot parse nested structures like balanced parentheses, nested HTML tags, or JSON/XML with arbitrary depth. Attempting this leads to brittle, incorrect patterns. Use proper parsers instead.

Java Double-Escaping OverheadIn Java string literals, backslash must be escaped: \d becomes \\d. Complex patterns become visually cluttered with double backslashes. Java 13+ text blocks (triple-quote) partially mitigate this for multi-line patterns.

Pattern.compile() Cost if MisusedCalling Pattern.compile() inside a loop or a frequently-called method (like a servlet handler) repeatedly compiles the same pattern, causing measurable performance degradation at scale.

False Confidence in ValidationRegex validation can give false confidence. An email regex may accept syntactically valid but non-existent addresses. A URL regex may accept malformed URLs that fail resolution. Always combine regex validation with semantic validation.

Java RegEx — Interview Questions

Java regex is tested in interviews both as standalone knowledge and as part of string processing problems. Master every question below.

Java provides two primary classes in java.util.regex: (1) Pattern — represents a compiled regular expression. Created via Pattern.compile(regex) or Pattern.compile(regex, flags). Immutable and thread-safe — should be shared as static final. (2) Matcher — the engine that applies a Pattern to a CharSequence input. Created via pattern.matcher(input). Not thread-safe — create one per thread. The String class also provides matches(), replaceAll(), replaceFirst(), and split() as convenience wrappers.

matches() — the entire input string must match the pattern from start to end. lookingAt() — the pattern must match starting from the beginning of the input, but the tail need not match. find() — searches anywhere in the input for the next substring that matches the pattern. Calling find() repeatedly in a loop finds all non-overlapping occurrences. Use matches() for validation, find() for search/extraction.

Greedy (default: *, +, ?) — matches as many characters as possible, then backtracks if the overall pattern fails. Lazy/Reluctant (*?, +?, ??) — matches as few characters as possible, then expands if needed. Possessive (*+, ++, ?+) — matches as many characters as possible and NEVER backtracks, even if the overall pattern fails. Possessive quantifiers prevent catastrophic backtracking and improve performance, but may cause fewer matches than greedy.

A capturing group (...) matches and stores the matched text — accessible via Matcher.group(n) where n is the 1-indexed group number. A non-capturing group (?:...) groups tokens for quantifier application without storing the match — it consumes no memory and doesn't shift group numbering. Named groups (?<name>...) are capturing groups accessible by name: Matcher.group("name"). Use non-capturing groups whenever you don't need to extract the matched text.

Pattern.compile() parses the regex string and builds an internal NFA/DFA representation — it is expensive. If declared as static final, it is compiled once at class loading time and reused for every match operation. If Pattern.compile() is called inside a method (especially one called inside a request handler or a loop), the pattern is recompiled on every call — wasting CPU and increasing latency. The JVM cannot optimize away repeated Pattern.compile() calls even if the regex string is a constant.

Both are zero-width assertions — they check surrounding context without consuming characters. Positive lookahead (?=...) — asserts that what follows the current position matches. Negative lookahead (?!...) — asserts that what follows does NOT match. Positive lookbehind (?<=...) — asserts that what precedes matches. Negative lookbehind (?<!...) — asserts that what precedes does NOT match. Example: \d+(?=px) matches digits only if followed by 'px' — the 'px' is not included in the match.

A backreference \n refers to the text matched by capturing group n and requires the same text to appear again at that position. Example: \b(\w+)\s+\1\b matches repeated consecutive words (duplicate word detection) — group 1 captures the first word, and \1 requires the exact same word to appear after whitespace. Named backreference: \k<name>. Backreferences are also used in replaceAll(): 'hello world'.replaceAll('(\w+) (\w+)', '$2 $1') swaps the two words.

ReDoS (Regular Expression Denial of Service) is a vulnerability where a crafted input causes exponential backtracking, consuming 100% CPU for minutes or crashing the application. It is triggered by nested quantifiers on overlapping character classes — e.g., (a+)+ on 'aaaaaaaaab' requires the engine to explore an exponential number of paths. Prevention: (1) avoid nested repetition on the same character class, (2) use possessive quantifiers (++) or atomic groups (?>...) to prevent backtracking, (3) set a match timeout using Matcher and interrupt long-running matches, (4) validate regex complexity with tools like regex101 or RE2J library for guaranteed linear time.

Pattern.quote(String s) returns a literal pattern string that matches the input string exactly, with all regex metacharacters escaped inside \Q...\E delimiters. Use it when you have a user-provided or runtime-generated string that you want to match literally — preventing accidental interpretation of characters like ., *, +, (, ), [, {, ^, $, |, ? as regex metacharacters. Example: Pattern.compile(Pattern.quote("3.14")) matches the literal string '3.14', not '3X14' or '3A14'.

appendReplacement(StringBuffer sb, String replacement) copies the input from the end of the previous match up to the current match start into sb, then appends the replacement string. It allows computing a dynamic replacement for each match inside a find() loop. appendTail(StringBuffer sb) appends the remainder of the input after the last match. Together they implement a full custom replacement loop: while (m.find()) { String custom = transform(m.group()); m.appendReplacement(sb, Matcher.quoteReplacement(custom)); } m.appendTail(sb); This is the correct pattern for transformations that depend on the matched content.

Practice Questions — Test Your Knowledge

Test your understanding of Java Regular Expressions with these practice questions. Attempt each answer before revealing it.

1. What is the difference between 'hello'.matches('hello') and Pattern.compile('hello').matcher('hello').find()? Will both return true?

Easy

✅ AnswerBoth return true for 'hello' vs 'hello', but for different reasons. String.matches() internally wraps the pattern in ^ and $ anchors — the entire string must match. Matcher.find() searches for the pattern anywhere in the string. For 'say hello world'.matches('hello') → false (full string doesn't match). For Pattern.compile('hello').matcher('say hello world').find() → true (finds 'hello' as a substring). Always use matches() for full-string validation and find() for substring search.

2. Write a regex to validate an Indian mobile number: starts with 6, 7, 8, or 9, followed by exactly 9 more digits.

Easy

3. What will the following code print? String s = "aabbaabb"; System.out.println(s.replaceAll("(.)\\1", "X"));

Medium

4. How would you extract all words between double quotes from a string? Write the pattern.

Medium

✅ AnswerPattern: "([^"]+)" — Breakdown: " matches a literal double quote; ([^"]+) capturing group matches one or more characters that are NOT a double quote (lazy approach without +?); " matches the closing double quote. In Java: Pattern.compile('"([^"]+)"') — use non-greedy [^"]+ for efficiency (no backtracking needed since the character class already excludes the delimiter). Usage: while (m.find()) { System.out.println(m.group(1)); }

5. What is catastrophic backtracking? Which of these patterns is vulnerable: (a) \d+ (b) (a+)+ (c) [a-z]+ (d) (.*)@(.*)

Hard

✅ Answer(b) (a+)+ is the classic catastrophic backtracking example. On input 'aaaaaab', the outer + and inner + create exponential combinations of ways to partition the 'a's between them before concluding no match. (d) (.*)@(.*) is also vulnerable on long strings without '@' — both .* can consume and release the entire string in exponential combinations. (a) \d+ and (c) [a-z]+ are safe — no nesting, no ambiguity. Fix (d) with: [^@]+@[^@]+ — exclude '@' from the character class to eliminate ambiguity.

6. Write a regex to split a string by either comma, semicolon, or pipe character, with optional surrounding whitespace.

Easy

7. How do you write a regex that matches a word only if it is NOT preceded by 'Mr.' or 'Ms.'? Give an example.

Hard

✅ AnswerUse a negative lookbehind: (?<!Mr\. |Ms\. )\b[A-Z][a-z]+\b — The lookbehind (?<!Mr\. |Ms\. ) asserts that the matched capitalized word is NOT preceded by 'Mr. ' or 'Ms. '. In 'Mr. Sharma and Rahul visited', this matches 'Rahul' but not 'Sharma'. Note: Java lookbehind must be fixed-width — variable-length lookbehinds are not supported in java.util.regex (unlike PCRE). Use alternation with fixed-length alternatives as shown.

8. Write a Java method that masks all but the last 4 digits of a credit card number string. Input: '4111 1111 1111 1111', Output: '**** **** **** 1111'.

Hard

✅ Answerstatic String maskCard(String card) { return card.replaceAll("\\d(?=\\d{4})", "*"); } — The pattern \d(?=\d{4}) matches any digit that is followed by exactly 4 more digits — i.e., all digits except the last four. The positive lookahead (?=\d{4}) is zero-width so spaces in the input are preserved. replaceAll() replaces each matched digit with '*'. Input '4111 1111 1111 1111' → '**** **** **** 1111'.

Conclusion — Regex: The Swiss Army Knife of Text Processing

Java Regular Expressions are one of those topics that separate junior developers from senior ones — not because the syntax is complex, but because knowing when, how, and how not to use them requires experience. A well-crafted regex with named groups, proper anchors, and a pre-compiled Pattern is elegant and efficient. A poorly written regex with nested quantifiers is a security vulnerability waiting to be exploited.

The mental model is this: Pattern is the compiled rulebook — build it once, share it widely. Matcher is the inspector — create one per input, apply the rules. Always anchor validation patterns. Prefer ?: over () when you don't need to capture. And reach for a parser — not regex — when facing nested or hierarchical data.

Task	Recommended Approach
Full-string format validation (email, phone, PAN)	✅ Pattern as static final + matcher.matches()
Search for a pattern within a larger text	✅ Pattern as static final + matcher.find() loop
Simple one-off string check	✅ String.matches() — convenience over performance
Split string by complex delimiter	✅ String.split(regex) or Pattern.compile(regex).split(input)
Replace with dynamic computed replacement	✅ appendReplacement() + appendTail() in find() loop
Extract structured fields (date parts, log fields)	✅ Named capturing groups (?<name>...) + group('name')
Match literal user-supplied string	✅ Pattern.quote(userInput) to prevent metachar injection
Parse nested HTML / JSON / XML	❌ Use jsoup / Jackson / JAXB — regex cannot handle nesting

Your next steps: practice writing regex on regex101.com (set flavor to Java 8) for instant visual feedback, study the Java NIO Files API for regex-based file scanning, and explore Spring's AntPathMatcher and PathPattern to see how regex principles apply to URL routing in enterprise applications. ☕

Frequently Asked Questions (FAQ)

A Regular Expression (regex) in Java is a sequence of characters that forms a search pattern used for matching, searching, extracting, and replacing text. Java provides regex support through the java.util.regex package, which contains the Pattern class (compiled regex pattern) and the Matcher class (engine that performs match operations on a string). The String class also has built-in regex methods: matches(), replaceAll(), replaceFirst(), and split().

Pattern is a compiled representation of a regular expression. Creating a Pattern is an expensive operation, so it should be compiled once and reused. Pattern.compile(regex) returns a Pattern object. Matcher is the engine that performs matching operations on a specific input string against a Pattern. A new Matcher is created for each input string via pattern.matcher(input). Key Matcher methods: find() searches for the next occurrence, matches() checks if the entire input matches, group() retrieves the matched text, start()/end() return match positions.

matches() attempts to match the entire input sequence against the pattern — the whole string must match the pattern from start to end. find() scans the input for the next subsequence that matches the pattern — it searches anywhere in the string and can find multiple non-overlapping matches by being called repeatedly. For checking if a substring matches, use find(). For validating that an entire string conforms to a pattern (e.g., email validation), use matches().

Groups in Java regex are portions of the pattern enclosed in parentheses (). They serve two purposes: (1) Grouping — applying a quantifier to a multi-character unit, e.g., (ab)+ matches 'ab', 'abab', 'ababab'. (2) Capturing — the matched text of each group is captured and accessible via Matcher.group(n) where n is the group number (1-indexed). Group 0 always refers to the entire match. Named groups use (?<name>...) syntax and are accessed via group('name').

Pattern.compile() parses and compiles the regex string into an internal finite automaton representation — this is a relatively expensive operation involving string parsing, syntax validation, and NFA/DFA construction. If you compile the same pattern inside a loop or method that is called frequently, you repeat this expensive work needlessly. Best practice: declare Pattern as a static final field so it is compiled once when the class loads and reused for every match operation throughout the application's lifetime.