Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Overview

When we work with regular expressions in Java, even a small syntax mistake can break our application at runtime. One of the most common errors we encounter is:

java.util.regex.PatternSyntaxException: Unclosed character class

In this tutorial, we’ll explore why this happens, how to reproduce it, and how to fix it. We also cover a real-world issue involving split() that often triggers this exception.

2. Understanding Character Classes

A character class in regex allows us to match any one character from a given set. This is one of the most commonly used regex constructs in Java.
Let us first look at a simple example of a character class:

"[abc]"

In this pattern, the regex engine matches either a, b, or c. We should always remember that a character class starts with [ and must end with ]. We can also define ranges when working with larger sets of characters:

"[a-z]"

This pattern matches any lowercase English letter from a to z. If we forget to close the bracket, Java will throw a runtime exception.

3. Reproducing the Exception

To better understand the problem, let us intentionally write an invalid regex pattern. This helps us see exactly how Java reacts:

public class RegexExample {
    public static void main(String[] args) {
        Pattern.compile("[a-z");
    }
}

In the above example, we try to compile a regex that starts a character class but never closes it. When we run this code, Java throws the following exception:

java.util.regex.PatternSyntaxException: Unclosed character class near index 4
[a-z
    ^

This clearly indicates that the regex parser expected a closing ] but did not find one.

4. Fixing the Exception

Now that we understand the problem, fixing it becomes straightforward. We simply need to close the character class properly:

Pattern.compile("[a-z]");

After making this change, the pattern compiles successfully without any errors. We should always verify that every opening bracket has a corresponding closing bracket.

5. Common Causes of This Exception

Let’s have a look at some of the common causes of PatternSyntaxException.

5.1. Missing Closing Bracket

One of the most frequent mistakes is forgetting to close the character class:

Pattern.compile("[0-9");

This pattern is incomplete and results in a runtime exception. We can fix it by adding the missing closing bracket:

Pattern.compile("[0-9]");

Even a small omission like this can break the entire regex.

5.2. Incorrect Nested Patterns

Sometimes, while writing a complex regex, we accidentally introduce extra brackets:

Pattern.compile("[a-zA-Z[0-9]");

In this pattern, we have an extra [ inside the character class. Character classes do not support nesting using [ like this, so the regex becomes invalid. As a result, Java throws a PatternSyntaxException.

To fix this, we should remove the unnecessary bracket and define the character set correctly:

Pattern.compile("[a-zA-Z0-9]");

Now the pattern is valid and matches any alphanumeric character. Instead of nesting, we should combine all required characters within a single character class.

6. Issue with split()

Let us now look at a practical example that often causes confusion in real projects. Before jumping into the issue, we first define a sample 2D array.

String[][] array2d = {
    {"a", "b"},
    {"c", "d"}
};

In many cases, we convert this array into a string using Arrays.deepToString() for quick inspection or processing:

String str = Arrays.deepToString(array2d);
System.out.println(str);

When we run this, the output looks like:

[[a, b], [c, d]]

Notice that the output contains nested square brackets. This is important for understanding the issue. Now, let us attempt to split this string into individual rows. At first glance, the following code looks correct:

String[][] split = new String[1][rows];
split[0] = str.split("], [");

However, when we run this code, we encounter a runtime exception:

java.util.regex.PatternSyntaxException: Unclosed character class

This happens because split() expects a regex, not a plain string. The pattern: “], [” is interpreted incorrectly, since [ and ] are special characters in regex. As a result, the regex engine treats [ as the start of a character class, leading to the exception.
To resolve this issue, we need to escape the square brackets so they are treated as literal characters:

split[0] = str.split("\\], \\[");

With this change, the regex becomes valid, and the code works as expected. Proper escaping ensures that special characters do not break our regex. Although the fix works, we can further improve the solution for cleaner output. The result of Arrays.deepToString() contains outer brackets that we may want to remove:

String str = Arrays.deepToString(array2d);
str = str.substring(1, str.length() - 1);

String[] result = str.split("\\], \\[");

By trimming the outer brackets, we get a cleaner split result. This makes the output easier to process and avoids unwanted characters.

7. Conclusion

In this article, we saw that the PatternSyntaxException: Unclosed character class is a common yet avoidable issue in Java. It usually occurs due to missing brackets or incorrect handling of special characters like [ and ]. By carefully writing regex patterns, properly escaping characters in methods like split(), and validating inputs, we can build more reliable applications. A small attention to detail in regex can prevent major runtime issues.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW