## Why is this an issue?

The `java.util.regex.Pattern.compile()` methods have a significant performance cost, and therefore should be used sensibly.

Moreover they are the only mechanism available to create instances of the Pattern class, which are necessary to do any pattern matching using regular expressions. Unfortunately that can be hidden behind convenience methods like `String.matches()` or `String.split()`.

It is therefore somewhat easy to inadvertently repeatedly compile the same regular expression at great performance cost with no valid reason.

This rule raises an issue when:

- A `Pattern` is compiled from a `String` literal or constant and is not stored in a static final reference.
- `String.matches`, `String.split`, `String.replaceAll` or `String.replaceFirst` are invoked with a `String` literal or constant. In which case the code should be refactored to use a `java.util.regex.Pattern` while respecting the previous rule.

### Noncompliant code example

    public void doingSomething(String stringToMatch) {
      Pattern regex = Pattern.compile("myRegex");  // Noncompliant
      Matcher matcher = regex.matcher("s");
      // ...
      if (stringToMatch.matches("myRegex2")) {  // Noncompliant
        // ...
      }
    }

### Compliant solution

    private static final Pattern myRegex = Pattern.compile("myRegex");
    private static final Pattern myRegex2 = Pattern.compile("myRegex2");

    public void doingSomething(String stringToMatch) {
      Matcher matcher = myRegex.matcher("s");
      // ...
      if (myRegex2.matcher(stringToMatch).matches()) {
        // ...
      }
    }

### Exceptions

`String.split` doesn’t create a regex when the string passed as argument meets either of these 2 conditions:

- It is a one-char String and this character is not one of the RegEx’s meta characters ".$|()[{^?*+\"
- It is a two-char String and the first char is the backslash and the second is not the ascii digit or ascii letter.

In which case no issue will be raised.