如何确定字符串是否不是正则表达式？

Question

I am trying to improve the performance of some code. It looks something like this:

public boolean isImportant(String token) {
    for (Pattern pattern : patterns) {
        return pattern.matches(token).find();
    }
}

What I noticed is that many of the Patterns seem to be simple string literals with no regular expression constructs. So I want to simply store these in a separate list (importantList) and do an equality test instead of performing a more expensive pattern match, such as follows:

public boolean isImportant(String token) {
    if (importantList.contains(token)) return true;

    for (Pattern pattern : patterns) {
        return pattern.matches(token).find();
    }        
}

How do I programmatically determine if a particular string contains no regular expression constructs?

Edit: I should add that the answer doesn't need to be performance-sensitive. (ie regular expressions can be used) I'm mainly concerned with the performance of isImportant() because it's called millions of times, while the initialzation of the patterns is only done once.

Answer 1

I normally hate answers that say this but...

Don't do that.

It probably won't make the code run faster, in fact it might even cause the program to take more time.

if you really need to optimize your code, there are likely much mush much more effective places where you can go.

Answer 2

It's going to be difficult. You can check for the non-presence of any regex metacharacters; that should be a good approximation:

Pattern regex = Pattern.compile("[$^()\\[\\]{}.*+?\\\\]");
Matcher regexMatcher = regex.matcher(subjectString);
regexIsLikely = regexMatcher.find();

Whether it's worth it is another question. Are you sure a regex match is slower than a list lookup (especially since you'll be doing a regex match after that in many cases anyway)? I'd bet it's much faster to just keep the regex match.

Answer 3

There is no way to determine it as every regex pattern is nothing else than a string. Furthermore there is nearly no performance difference as regex is smart nowadays and I'm pretty sure, if the pattern and source lengths are the same, equity check is the first that will be done

Answer 4

This is wrong

    for (Pattern pattern : patterns) 

you should create one big regex that ORs all patterns; then for each input you only match once.