A Java Regex Tester

Type a pattern the way you’d write it in Java, without the extra string-literal backslashes, and the tester shows what find() and matches() return, every group, and the result of replaceAll(). The Java code at the bottom has the escaping done for you.

Released 2026-08-02, updated 2026-10-16.

Pattern pattern = Pattern.compile("(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})");
Matcher matcher = pattern.matcher(input);
while (matcher.find()) {
    System.out.println(matcher.group() + " at " + matcher.start());
}
String result = matcher.replaceAll("${day}/${month}/${year}");

Running a pattern in Java

Java 9 added stream-friendly methods to Matcher. Pick your Java version once and every example on this page switches with it; the choice is remembered on your next visit.

Collecting all matches

List<String> dates = new ArrayList<>();
Matcher matcher = Pattern.compile("\\d{4}-\\d{2}-\\d{2}").matcher(text);
while (matcher.find()) {
    dates.add(matcher.group());
}

List<String> dates = Pattern.compile("\\d{4}-\\d{2}-\\d{2}")
    .matcher(text)
    .results()
    .map(MatchResult::group)
    .collect(Collectors.toList());

Replacing with a computed value

Matcher matcher = Pattern.compile("\\b[a-z]").matcher(text);
StringBuffer sb = new StringBuffer();
while (matcher.find()) {
    matcher.appendReplacement(sb, matcher.group().toUpperCase());
}
matcher.appendTail(sb);
String result = sb.toString();

String result = Pattern.compile("\\b[a-z]")
    .matcher(text)
    .replaceAll(m -> m.group().toUpperCase());

In both versions, the replacement text is still read as a replacement string, so a $ or \ in it is treated as a group reference or escape. Wrap computed text in Matcher.quoteReplacement(...) when it might contain either.

Common surprises

• matches() vs find(). String.matches and Matcher.matches() require the whole input to match. find() looks for the pattern anywhere. The tester shows both.
• Double escaping. The regex \d+ is written "\\d+" in Java source, and a literal backslash is "\\\\". Text blocks don’t help here: they process escapes the same way.
• $ without MULTILINE matches at the very end or just before a final line break, so "abc\n" matches abc$. Use \z for the absolute end.
• Compile once. String.matches and String.replaceAll compile the pattern on every call, and so does split unless the separator is a single plain character. In a loop, keep a static final Pattern instead.