How to Fix PatternSyntaxException: “Illegal repetition near index” in Java

1. Overview

Few issues in Java regex are as frustrating as encountering “java.util.regex.PatternSyntaxException: Illegal repetition near index X”. This common exception occurs when regex quantifiers, the powerful symbols that control repetition, are misused or misplaced within the pattern.

As a result, working with regular expressions, which are essential tools for pattern matching, validation, and parsing, can become challenging due to their unforgiving syntax. Consequently, misusing quantifiers can cause both visible exceptions and hidden matching issues.

In this tutorial, we’ll explore what this exception means, examine its common causes, and most importantly, show how to fix it so our regex patterns work smoothly.

2. Understanding the Exception

Java throws a PatternSyntaxException whenever the regex pattern contains a syntax error, stopping the compilation of the pattern. The specific “Illegal repetition near index” message indicates that one of the repetition operators (quantifiers) in the regex is incorrectly used or placed.

Before diving into fixes, it’s important to refresh our understanding of common quantifiers in regex:

• ‘*’ matches the preceding element zero or more times
• ‘+’ matches one or more times
• ‘?’ matches zero or one time
• ‘{n}‘ matches exactly n times
• ‘{n,}’ matches n or more times
• ‘{n,m}’ matches between n and m times

Each quantifier operates on the element immediately preceding it, whether a character, group, or character class.

However, this exception occurs when quantifiers are improperly positioned within the pattern or written with invalid syntax, such as missing braces or incorrect escaping.

Therefore, understanding the strict syntax rules behind quantifiers is crucial to preventing this error.

3. What Causes “Illegal Repetition” in Regex?

This exception can arise from various common mistakes related to quantifiers in regular expression patterns. We’ll examine the most frequent causes and how to fix them, accompanied by illustrative examples.

3.1. Orphaned Quantifier

A quantifier must follow a valid character, group, or character class. If it appears at the beginning of a pattern or follows an invalid element, it has nothing to apply to and causes an error:

Pattern.compile("*[a-z]"); // Invalid: orphaned quantifier

In this example, the asterisk is placed before any valid element, so the engine cannot determine what to repeat. To correct this, we ensure the quantifier follows a valid target:

Pattern.compile("[a-z]*abc"); // Valid

We must always double-check that quantifiers are not orphaned or placed at the beginning.

3.2. Nested Quantifiers Without Grouping

It is not allowed to place one quantifier directly after another without grouping. When quantifiers are stacked without clarity, the engine cannot interpret the pattern correctly:

Pattern.compile("\\d+\\.?\\d+*"); // Invalid: nested quantifiers without grouping

Here, the ‘*’ quantifier attempts to apply directly to ‘\\d+’ without grouping, which is an illegal operation. The correct approach is to group the quantified expression so that the outer quantifier applies to the entire repetition:

Pattern.compile("\\d+(\\.\\d+)*"); // Valid

Grouping clarifies what is being quantified, preventing ambiguity and syntax errors.

3.3. Unclosed or Malformed Curly Braces

Curly braces are used for specifying exact or ranged repetition counts. They must follow the correct syntax. Leaving them unclosed or malformed causes a PatternSyntaxException:

Pattern.compile("\\d{2,"); // Invalid: unclosed curly brace

This example is incomplete, and the regex engine cannot parse the repetition instruction. To fix this, use a properly formatted range:

Pattern.compile("\\d{2,4}"); // Valid

We should also avoid using incomplete repetition ranges or missing numbers in the curly braces, such as ‘d{,4}’, which Java does not accept.

3.4. Quantifying Unrepeatable or Improper Elements

A quantifier must apply to a valid and complete element. When a quantifier is placed immediately after another, the engine cannot interpret the pattern unless the first part is grouped:

Pattern.compile("\\w+\\s+*"); // Invalid: improper quantification

In this case, the ‘*’ quantifier tries to apply to the preceding quantifier ‘+’ on ‘\\s’ without grouping, which is invalid. The solution is to wrap the quantified expression in parentheses:

Pattern.compile("(\\w+\\s+)*"); // Valid

This tells the regex engine to apply the second quantifier to the entire grouped repetition.

3.5. Escaping Literal Quantifier Characters

Sometimes, we need to match quantifier symbols as literal characters rather than as regular expression operators. Forgetting to escape them causes the regex engine to treat them as quantifiers, which may lead to errors if they’re misused:

Pattern.compile("abc+*"); // Invalid: unescaped literal quantifiers

In this case, the intent might be to match the literal string ‘abc+*’, but the pattern fails because ‘*’ is being treated as a quantifier applied to ‘c+’. To match the symbols, they must be escaped, and in Java strings, this requires double backslashes:

Pattern.compile("abc\\+\\*"); // Valid

Proper escaping ensures that the regex engine treats these characters as literals, not operators.

4. Best Practices to Avoid This Exception

To avoid PatternSyntaxException related to illegal repetition, we can follow a few best practices:

• Always place quantifiers only after a valid token (character, character class, or group)
• Never start a regex pattern with a quantifier
• Use parentheses to group elements when applying multiple quantifiers to the same section
• Ensure all brace quantifiers are fully written, with both opening and closing braces
• Escape special characters when the goal is to match them literally
• Use the index in the exception message to quickly locate errors
• Test and validate the regex patterns using trusted online regex testing tools
• When building regex patterns dynamically, sanitize inputs and validate the final pattern

5. Conclusion

The “PatternSyntaxException: Illegal repetition near index” is a frequent error encountered when working with Java regular expressions. Fortunately, it’s usually easy to resolve. This exception typically arises from incorrect placement of quantifiers, malformed syntax, or attempts to apply quantifiers to elements that cannot be repeated, such as anchors or certain special characters.

Mastering quantifier usage and systematically reviewing patterns helps efficiently troubleshoot these errors. Important areas to verify include ensuring that quantifiers are correctly positioned, repetition ranges are properly closed, and special characters are appropriately escaped.