带参数的Pattern.compile（）

Question

说我有这段代码：

public static boolean checkRegex(String regex, String value) {
        if (value == null) return false;
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(value);
        return matcher.matches();
    }
.......

checkRegex("^.+@.+\\..+$", "email@example.com");

我的正则表达式会在编译时编译一次还是在运行时编译多次？

Answer 1

Pattern.compile(regex)只是一种对编译器没有特殊意义的方法，因此只能在运行时执行。 尽管可以缓存已编译的模式（这是用其他语言（例如Python）完成的），但是Sun / Oracle的Pattern的实现不会缓存已编译的Pattern ，这意味着您每次执行checkRegex方法（即使使用相同的regex） ），您将再次编译正则表达式并获得一个新的Pattern实例。

对了你的方法

public static boolean checkRegex(String regex, String value) {
    if (value == null) return false;
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(value);
    return matcher.matches();
}

可以改写成

public static boolean checkRegex(String regex, String value) {
    if (value == null) 
        return false;
    return value.matches(regex);
}

Answer 2

简短答案

尽管从理论上讲也许是可行的，但是没有。 不在编译时 ，这些将再次编译。

但是Pattern使用Flyweight模式，这样，一旦正则表达式被编译，就将其存储在内存中， 因此在运行时不需要完全编译 。

编译时间

从理论上讲，编译器可能会执行所谓的恒定传播 ，从而在编译时解决问题。 鉴于您调用的方法是最终方法（或在编译时知道被调用方），可以完成此操作。

但是，如果有人编译您的方法并检查Java字节码 ，它将编译为：

public static boolean checkRegex(java.lang.String, java.lang.String);
    Code:
       0: aload_1       
       1: ifnonnull     6
       4: iconst_0      
       5: ireturn       
       6: aload_0       
       7: invokestatic  #15                 // Method java/util/regex/Pattern.compile:(Ljava/lang/String;)Ljava/util/regex/Pattern;
      10: astore_2      
      11: aload_2       
      12: aload_1       
      13: invokevirtual #16                 // Method java/util/regex/Pattern.matcher:(Ljava/lang/CharSequence;)Ljava/util/regex/Matcher;
      16: astore_3      
      17: aload_3       
      18: invokevirtual #17                 // Method java/util/regex/Matcher.matches:()Z
      21: ireturn       

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #18                 // String ^.+@.+\..+$
       2: ldc           #19                 // String email@example.com
       4: invokestatic  #20                 // Method checkRegex:(Ljava/lang/String;Ljava/lang/String;)Z
       7: pop
       ...

如您所见，方法被简单地转换为Java字节码，并且使用两个参数调用该方法。

一些编译器（大多数是功能和逻辑编程语言的编译器）允许程序专门化 ：如果使用常量完成某个调用，则编译器可以创建该方法的副本并解决编译时已知的问题。 但是，这是一个折衷 ，因为引入了大量的专用方法将减少大量的代码库。

轻量级模式在运行时

如果深入研究java.util.regex.Pattern的Java字节码，您将看到：

private static final HashMap<String, CharPropertyFactory> map;

static CharProperty charPropertyFor(String name) {
        // <editor-fold defaultstate="collapsed" desc="Compiled Code">
        /* 0: getstatic     java/util/regex/Pattern$CharPropertyNames.map:Ljava/util/HashMap;
         * 3: aload_0
         * 4: invokevirtual java/util/HashMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
         * 7: checkcast     java/util/regex/Pattern$CharPropertyNames$CharPropertyFactory
         * 10: astore_1
         * 11: aload_1
         * 12: ifnonnull     19
         * 15: aconst_null
         * 16: goto          23
         * 19: aload_1
         * 20: invokevirtual java/util/regex/Pattern$CharPropertyNames$CharPropertyFactory.make:()Ljava/util/regex/Pattern$CharProperty;
         * 23: areturn
         *  */
        // </editor-fold>
    }

注意HashMap ，所以这意味着Pattern存储正则表达式的片段及其对应的micro-DFA，这种行为称为Flyweight 。 这意味着您只编译一次正则表达式。 显然，您仍然必须执行查找，因此这不是免费的优化，但肯定会有所帮助。