Java-正则表达式模式编译最佳实践（带有枚举）

Question

I'm trying to create an enum which holds the regex string, while making sure that the pattern only compiles once because pattern compilation is expensive and I do reuse the same pattern a lot. I'm trying to achieve a dynamically compiled Pattern object depending of the type of enum selected. However, I'm stuck at the following. Can anyone kindly provide some guidance, or suggest a better way of achieving this?

public enum LOG_SCANNER{
    FOO_STRING(".*XXXX$"),
    BAR_STRING(".*YYYY.*"),
    ;

    static Pattern p;
    static {
        p = Pattern.compile(regex); // Compilation failes here

    }


    String regex;
    private LOG_NAME_MATCHER(String regex) {
        this.regex = regex;
    }


}

edit: Please note that i'm not using regex to search for something that could be achieved with String.endsWith() or .contains(). ( ".*XXXX$" ) is simply an example.

Answer 1

What about:

public enum LogNameMatcher{
    FOO_LOG(".*Foo\\.log$"),
    BAR_LOG(".*bar\\.log$");

    private final Pattern pattern;

    private LogNameMatcher(final String regex) {
        this.pattern = Pattern.compile(regex);
    }

    public Pattern getPattern() { return this.pattern; }
}

or (as stated in comments)

public final class LogNameMatcher {
    public static final Pattern FOO_LOG = Pattern.compile(".*Foo\\.log$");
    public static final Pattern BAR_LOG = Pattern.compile(".*bar\\.log$");

    private LogNameMatcher() {
        // util class
    }
}

Answer 2

Following the discussion, an alternative might be to collect the patterns in some Collection:

List<Pattern> patterns = new ArrayList<>();
for( String ps: new String[]{ "...Foo...", "...bar...",... } ){
    patterns.add( Pattern.compile( ps ) );
}

Code using this List of Pattern to establish a match is straightforward, more so than iterating over an EnumSet.

Also, you might do

String[] patstrs = new String[]{ "(.*Foo.*)", "(.*bar.*)", "(.blech.)"};
String ap = String.join( "|", patstrs );
Pattern p = Pattern.compile( ap );
String t = "a Foo is here";
Matcher m = p.matcher( t );
if( m.matches() ){
    for( int i = 1; i <= m.groupCount(); i++ ){
        if( m.group(i) != null ){
            System.out.println( "#" + i + " matches" );
        }
    }
}

This is meant to indicate that you can look for all patterns at the same time while maintaining the patterns as isolated entities. Further processing can be associated with the string index.