Roland's Blog (Posts about regex)

Java Regex: Dynamic Replacements with Lambda Expressions

Roland Weisleder — Thu, 03 Jul 2025 14:15:00 GMT

Regular expressions are a powerful tool to find patterns in strings. Static replacements are also relatively easy to implement. When it comes to dynamic replacements, things get more interesting.

Static replacements

Suppose we want to convert all ISO dates in a string into the European format DD.MM.YYYY for our users.

String input = "Lorem ipsum 2023-11-07 dolor sit 2021-09-14 amet.";
Pattern isoDatePattern = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
String output = isoDatePattern.matcher(input).replaceAll("$3.$2.$1");
// "Lorem ipsum 07.11.2023 dolor sit 14.09.2021 amet."

For a static replacement, we can access each group of a match using the dollar notation.

But suppose we now want to show our users the dates in a long form, depending on their locale. The result should look something like this:

Locale locale = Locale.US;
String input = "Lorem ipsum 2023-11-07 dolor sit 2021-09-14 amet.";
String output = // ...
// "Lorem ipsum November 7, 2023 dolor sit September 14, 2021 amet."

In this case, we cannot simply transform the groups. Instead, we have to dynamically execute additional code for each match. Depending on the Java version we are using, we have various options.

One Step Towards Maintainable Regular Expressions In Java

Roland Weisleder — Tue, 13 May 2025 18:00:00 GMT

Regular expressions are a great way to extract data from strings. In Java, we typically use Pattern and Matcher:

String parseDate(String input) {
    Pattern datePattern = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
    Matcher dateMatcher = datePattern.matcher(input);
    if (!dateMatcher.matches()) {
        throw new IllegalArgumentException("Invalid date format");
    }

    String year = dateMatcher.group(1);
    String month = dateMatcher.group(2);
    String day = dateMatcher.group(3);

    return "Year: " + year + ", Month: " + month + ", Day: " + day;
}

This works, but it´s not great.

There are a few things I don´t like about regular expressions and this example in particular:

The regex itself is already quite cryptic.
Group access via numbers is hard to follow.
Any change to the regex might require me to recount and update group indices.

Honestly, I don’t want to count parentheses every time I tweak something. It´s error-prone!

The good news is, there is a better alternative since Java 7. Surprisingly, it´s still rarely used. And no, it´s not extracting magic numbers into public static final int THREE = 3; to keep Sonar happy. (If you’re still on Java 6 or below: let’s talk.)