Java Pattern Class: Compiling and Reusing Regular Expressions
Learn how to use the Java Pattern class to compile and reuse regular expressions efficiently, avoid common pitfalls, and improve matching performance.

The java.util.regex.Pattern class is the entry point for regular expression matching in Java. Instead of parsing a regex string on every match, you compile it once into a Pattern instance, then use it to create Matcher objects for specific input strings. This separation is the foundation of efficient and readable regex handling in Java.
Compiling a Regular Expression with Pattern
A Pattern is created by calling the static compile method with a regex string. The simplest form takes only the pattern text:
Pattern emailPattern = Pattern.compile("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}");The compile method parses the regex and builds an internal state machine. This process is relatively expensive, so it should not be repeated for every match if the same pattern is used frequently. The Pattern instance is immutable and can be safely shared.
You can also pass flags as a second argument. Flags modify how the pattern behaves, such as case-insensitive matching or multiline mode. For example:
Pattern caseInsensitivePattern = Pattern.compile("error", Pattern.CASE_INSENSITIVE);Creating a Matcher and Performing Matches
A Pattern alone does not match anything. You need a Matcher, which is created by calling matcher on the pattern with the input string:
Pattern digitPattern = Pattern.compile("\\d+");
Matcher matcher = digitPattern.matcher("Order 12345 shipped");
if (matcher.find()) {
System.out.println("Found: " + matcher.group());
}find scans the input for the next match, while matches requires the entire input to match the pattern. The distinction is critical:
Pattern p = Pattern.compile("abc");
System.out.println(p.matcher("abc").matches()); // true
System.out.println(p.matcher("xabc").matches()); // false
System.out.println(p.matcher("xabc").find()); // trueMatcher also supports capturing groups, which are defined by parentheses in the regex. After a successful match, you can retrieve groups by index or name:
Pattern keyValue = Pattern.compile("(\\w+)=(\\w+)");
Matcher m = keyValue.matcher("name=John");
if (m.matches()) {
System.out.println(m.group(1)); // name
System.out.println(m.group(2)); // John
}Using Pattern Flags to Change Matching Behavior
Flags are constants in the Pattern class that alter how the regex engine interprets the pattern. The most commonly used flags are:
| Flag | Effect |
|---|---|
Pattern.CASE_INSENSITIVE | Matches letters ignoring case. |
Pattern.MULTILINE | ^ and $ match at the start/end of each line, not just the whole input. |
Pattern.DOTALL | . matches any character including line terminators. |
Pattern.COMMENTS | Allows whitespace and comments in the pattern for readability. |
Pattern.LITERAL | Treats the pattern as a literal string, escaping all metacharacters. |
For example, to match a word at the beginning of each line in a multi-line string:
Pattern multiline = Pattern.compile("^\\w+", Pattern.MULTILINE);
Matcher m = multiline.matcher("first line\nsecond line");
while (m.find()) {
System.out.println(m.group()); // prints "first" then "second"
}Flags can be combined with the bitwise OR operator: Pattern.CASE_INSENSITIVE | Pattern.MULTILINE. You can also embed flags directly in a pattern with constructs such as (?i) for case-insensitive matching or (?m) for multiline mode.
Reusing Patterns to Avoid Repeated Compilation
Compiling a regex is CPU-intensive because it involves parsing and constructing an internal automaton. If the same pattern is used in a loop or a frequently called method, compiling it each time is wasteful. Consider this anti-pattern:
for (String line : lines) {
if (line.matches("\\d{4}-\\d{2}-\\d{2}")) { // compiles the regex every time
// ...
}
}String.matches internally calls Pattern.compile on each invocation. Instead, compile once outside the loop:
Pattern datePattern = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");
for (String line : lines) {
if (datePattern.matcher(line).matches()) {
// ...
}
}This is especially important in server-side code where the same validation runs on many requests. The compiled Pattern is thread-safe and immutable, so you can store it in a static final field:
public class EmailValidator {
private static final Pattern EMAIL_PATTERN =
Pattern.compile("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}");
public boolean isValid(String email) {
return EMAIL_PATTERN.matcher(email).matches();
}
}Common Mistakes and How to Avoid Them
One frequent mistake is confusing find with matches. matches requires the entire input to match, while find searches for a substring. For example, Pattern.compile("\\d+").matcher("abc123").matches() returns false, but find() returns true. Always choose the method that matches your intent.
Another pitfall is forgetting to quote metacharacters when you want a literal match. If you need to match a dot or a dollar sign, escape it with a backslash, but remember that in a Java string, a backslash is itself escaped: "\\." matches a literal dot. Alternatively, use Pattern.quote to escape the entire string:
String literal = "a.b*c";
Pattern p = Pattern.compile(Pattern.quote(literal));Also, be careful with the Matcher state. A Matcher is stateful; after a successful match, the position advances. If you need to reuse the same matcher for a different input, call reset with the new input. But it is often simpler to create a new Matcher from the shared Pattern.
Pattern vs String.matches and Other Alternatives
String.matches is convenient for one-off checks, but it compiles the regex every time. For repeated use, a precompiled Pattern is better. There are also higher-level APIs like java.util.regex.Pattern.split and String.replaceAll, which internally use Pattern. If you need to split a string with a regex, Pattern.split is more efficient than String.split when the pattern is reused, because String.split compiles the pattern each call.
For simple literal substring searches, String.indexOf or contains are faster than regex. Regex should be used when you need pattern matching, not just fixed text. Overusing regex for trivial operations adds unnecessary complexity and runtime cost.
Thread Safety and Pattern Reuse in Concurrent Code
Pattern instances are immutable and thread-safe. Multiple threads can safely share a single Pattern and call matcher on it without synchronization. However, Matcher instances are not thread-safe. Each thread should create its own Matcher from the shared pattern. This is a common source of concurrency bugs when developers mistakenly share a Matcher across threads.
public class RegexService {
private static final Pattern TOKEN_PATTERN = Pattern.compile("\\w+");
public List<String> extractTokens(String input) {
Matcher m = TOKEN_PATTERN.matcher(input); // local matcher per call
List<String> tokens = new ArrayList<>();
while (m.find()) {
tokens.add(m.group());
}
return tokens;
}
}In high-throughput systems, the cost of creating a Matcher is small compared to compilation. If you need to match the same pattern against many strings, reuse the Pattern and create a new Matcher for each input. This keeps the code thread-safe and avoids unnecessary object state sharing.
When using Pattern in a static initializer, ensure the regex is valid; an invalid regex throws PatternSyntaxException at class load time, which can crash the application. Validate regexes in development and consider logging the exception context to make the error message more actionable.
For long-running applications, monitor the number of distinct patterns compiled. If you dynamically compile patterns from user input, you risk exhausting memory with many unique Pattern objects. In such cases, consider caching patterns with a bounded cache keyed by the regex string and flags. The Pattern class itself does not provide a cache, but you can implement a simple ConcurrentHashMap with a maximum size to reuse common patterns while bounding memory usage.
Try matching browser tools
All toolsSmall utilities that fit Java work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Java guides
All Java guidesJava Final Keyword: Usage and Behavior
How Java's final keyword works for variables, methods, and classes, with practical examples and decision guidance for using it.
Java Final Variable: Syntax, Behavior, and Use Cases
Understand what a final variable in Java means, how initialization works, and when to use it for constants, immutability, and clearer code.
Java Duration vs Period: When to Use Each
java duration vs period: Compare Java Duration and Period to handle time-based and date-based calculations correctly. Learn syntax, conversion, and pitfalls.
Instance vs Static Variables in Java: Key Differences
Understand the difference between instance and static variables in Java, including memory, lifecycle, and when to use each.
More in Java
All Java guidesThe guides filed next to this one in Java, in library order.