Understanding the Pattern.quote Method

Last updated: January 8, 2024

Written by: baeldung

Reviewed by: Bruno Fontana

Core Java

Regex

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.

1. Overview

When using regular expressions in Java, sometimes we need to match regex patterns in their literal form – without processing any metacharacters present in those sequences.

In this quick tutorial, let’s see how we can escape metacharacters inside regular expressions both manually and using the Pattern.quote() method provided by Java.

2. Without Escaping Metacharacters

Let’s consider a string holding a list of dollar amounts:

String dollarAmounts = "$100.25, $100.50, $150.50, $100.50, $100.75";

Now, let’s imagine we need to search for occurrences of a specific amount of dollars inside it. Let’s initialize a regular expression pattern string accordingly:

String patternStr = "$100.50";

First off, let’s find out what happens if we execute our regex search without escaping any metacharacters:

public void whenMetacharactersNotEscaped_thenNoMatchesFound() {
    Pattern pattern = Pattern.compile(patternStr);
    Matcher matcher = pattern.matcher(dollarAmounts);

    int matches = 0;
    while (matcher.find()) {
        matches++;
    }

    assertEquals(0, matches);
}

As we can see, matcher fails to find even a single occurrence of $150.50 within our dollarAmounts string. This is simply due to patternStr starting with a dollar sign which happens to be a regular expression metacharacter specifying an end of a line.

As you probably should have guessed, we’d face the same issue over all the regex metacharacters. We won’t be able to search for mathematical statements that include carets (^) for exponents like “5^3“, or text that use backslashes (\) such as “users\bob“.

3. Manually Ignore Metacharacters

So secondly, let’s escape the metacharacters within our regular expression before we perform our search:

public void whenMetacharactersManuallyEscaped_thenMatchingSuccessful() {
    String metaEscapedPatternStr = "\\Q" + patternStr + "\\E";
    Pattern pattern = Pattern.compile(metaEscapedPatternStr);
    Matcher matcher = pattern.matcher(dollarAmounts);

    int matches = 0;
    while (matcher.find()) {
        matches++;
    }

    assertEquals(2, matches);
}

This time, we have successfully performed our search; But this can’t be the ideal solution due to a couple of reasons:

String concatenation carried out when escaping the metacharacters that make the code more difficult to follow.
Less clean code due to the addition of hard-coded values.

4. Use Pattern.quote()

Finally, let’s see the easiest and cleanest way to ignore metacharacters in our regular expressions.

Java provides a quote() method inside their Pattern class to retrieve a literal pattern of a string:

public void whenMetacharactersEscapedUsingPatternQuote_thenMatchingSuccessful() {
    String literalPatternStr = Pattern.quote(patternStr);
    Pattern pattern = Pattern.compile(literalPatternStr);
    Matcher matcher = pattern.matcher(dollarAmounts);

    int matches = 0;
    while (matcher.find()) {
        matches++;
    }

    assertEquals(2, matches);
}

5. Conclusion

In this article, we looked at how we can process regular expression patterns in their literal forms.

We saw how not escaping regex metacharacters failed to provide the expected results and how escaping metacharacters inside regex patterns can be performed manually and using the Pattern.quote() method.

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.