Resolving Patternsyntaxexception: Unclosed Character Class

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.

As always, the code presented in this article is available over on GitHub.