Roland's Blog

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.)

Read more… (2 min remaining to read)

The Flag Parameter Anti-Pattern

Roland Weisleder — Thu, 03 Nov 2022 11:00:00 GMT

While implementing a new feature, I came across the flag parameter anti-pattern in two unrelated places. I would like to take this as an opportunity to take a closer look at this anti-pattern.

A simple example

Lets assume we want to load all PDF documents via an API method. This could look like this:

public interface DocumentService {

    Document[] loadDocuments();
}

Read more… (2 min remaining to read)

Why Unit Tests Will Save You a Lot of Time

Roland Weisleder — Wed, 07 Sep 2022 07:40:00 GMT

When you as a developer hear that you should write unit tests, it sounds like more effort at first. The code you have written works, as you have already seen by trying it.

However, the world around it is constantly changing. And how can you be sure that the code still works despite changes from the outside?

Date Format?

Let's assume that in our program there is a function to parse strings as dates.

/**
 * @param input a date with format "dd.MM.yy HH:mm"
 */
public static Date parseDate(String input) throws ParseException {
    return DateFormat.getInstance().parse(input);
}

We use a class from the JDK here and even describe in the Javadoc which format the input parameter should have. Once we have tried this, what else can go wrong? Surely this will work forever.

Even after updating from Java 8 to Java 11, everyone would assume that the function still works as described, right? After all, we are only using a class from the JDK.

Read more… (2 min remaining to read)

Maven Doesn't Execute All JUnit Tests by Default

Roland Weisleder — Thu, 13 Sep 2018 18:16:00 GMT

We as developers write many unit tests. The CI pipeline will run all tests with every build. We trust that, if the status is green, everything should be okay.

But what if the unit tests should have failed? I recently learned that Maven does not execute all tests by default.

Consider this simple class:

public class MyTests {

    @Test
    public void firstTest() {
        assertEquals(2, 1 + 1);
    }

    public static class NestedTests {

        @Test
        public void secondTest() {
            assertEquals(3, 1 + 1);
        }
    }
}

We see that firstTest should succeed and secondTest should fail.

Read more… (2 min remaining to read)