java.util.regex - Pattern.compile() 的重要性？

Question

Pattern.compile()方法的重要性是什么？
为什么我需要在获取Matcher 对象之前编译正则表达式字符串？

例如：

String regex = "((\\S+)\\s*some\\s*";

Pattern pattern = Pattern.compile(regex); // why do I need to compile
Matcher matcher = pattern.matcher(text);

Answer 1

Pattern.compile() 允许多次重用正则表达式（它是线程安全的）。性能优势可能非常显着。

我做了一个快速基准测试：

    @Test
    public void recompile() {
        var before = Instant.now();
        for (int i = 0; i < 1_000_000; i++) {
            Pattern.compile("ab").matcher("abcde").matches();
        }
        System.out.println("recompile " + Duration.between(before, Instant.now()));
    }

    @Test
    public void compileOnce() {
        var pattern = Pattern.compile("ab");
        var before = Instant.now();
        for (int i = 0; i < 1_000_000; i++) {
            pattern.matcher("abcde").matches();
        }
        System.out.println("compile once " + Duration.between(before, Instant.now()));
    }

compileOnce 的速度在 3 倍到 4 倍之间。 我想这很大程度上取决于正则表达式本身，但对于经常使用的正则表达式，我选择static Pattern pattern = Pattern.compile(...)

Answer 2

Pattern 类是正则表达式引擎的入口点。您可以通过 Pattern.matches() 和 Pattern.comiple() 使用它。 #这两者的区别。 ma​​tches()- 用于快速检查文本（字符串）是否匹配给定的正则表达式 comiple()- 创建 Pattern 的引用。所以可以多次使用正则表达式匹配多个文本。

供参考：

public static void main(String[] args) {
     //single time uses
     String text="The Moon is far away from the Earth";
     String pattern = ".*is.*";
     boolean matches=Pattern.matches(pattern,text);
     System.out.println("Matches::"+matches);

    //multiple time uses
     Pattern p= Pattern.compile("ab");
     Matcher  m=p.matcher("abaaaba");
     while(m.find()) {
         System.out.println(m.start()+ " ");
     }
}

Answer 3

与“Pattern.compile”类似，还有“RECompiler.compile”[来自 com.sun.org.apache.regexp.internal]，其中：
1。模式 [a-z] 的编译代码中包含“az”
2。模式 [0-9] 的编译代码中包含“09”
3。模式 [abc] 的编译代码中包含“aabbcc”。

因此，编译后的代码是概括多种情况的好方法。因此，而不是有不同的代码处理情况 1,2 和 3 。问题减少到与编译代码中当前和下一个元素的 ascii 进行比较，因此是对。 因此
一个。在 a 和 z 之间带有 ascii 的任何东西都在 a 和 z 之间
乙。 'a 和 a 之间带有 ascii 的任何东西都绝对是 'a'

Answer 4

这是性能和内存使用的问题，如果您需要大量使用它，请编译并保留已编译的模式。 正则表达式的典型用法是验证用户输入（格式），以及为用户格式化输出数据，在这些类中，保存已编译的模式，看起来很合乎逻辑，因为它们通常调用很多。

下面是一个示例验证器，它确实被称为很多:)

public class AmountValidator {
    //Accept 123 - 123,456 - 123,345.34
    private static final String AMOUNT_REGEX="\\d{1,3}(,\\d{3})*(\\.\\d{1,4})?|\\.\\d{1,4}";
    //Compile and save the pattern  
    private static final Pattern AMOUNT_PATTERN = Pattern.compile(AMOUNT_REGEX);


    public boolean validate(String amount){

         if (!AMOUNT_PATTERN.matcher(amount).matches()) {
            return false;
         }    
        return true;
    }    
}

正如@Alan Moore 所提到的，如果您的代码中有可重用的正则表达式（例如在循环之前），您必须编译并保存模式以供重用。

Answer 5

compile() 方法总是在某个时候被调用；这是创建 Pattern 对象的唯一方法。所以问题是，为什么要明确地称它为？一个原因是您需要对 Matcher 对象的引用，以便您可以使用它的方法，例如 group(int) 来检索捕获组的内容。获取 Matcher 对象的唯一方法是通过 Pattern 对象的 matcher() 方法，而获取 Pattern 对象的唯一方法是通过 compile() 方法。然后是find() 方法，与matches() 不同，它不会在String 或Pattern 类中重复。

另一个原因是避免一遍又一遍地创建相同的 Pattern 对象。每次使用 String 中的正则表达式驱动方法之一（或 Pattern 中的静态 matches() 方法）时，它都会创建一个新 Pattern 和一个新 Matcher。所以这段代码sn-p：

for (String s : myStringList) {
    if ( s.matches("\\d+") ) {
        doSomething();
    }
}

...完全等价于：

for (String s : myStringList) {
    if ( Pattern.compile("\\d+").matcher(s).matches() ) {
        doSomething();
    }
}

显然，这做了很多不必要的工作。事实上，与执行实际匹配相比，编译正则表达式和实例化 Pattern 对象很容易花费更长的时间。因此，将这一步拉出循环通常是有意义的。您也可以提前创建 Matcher，尽管它们的成本并不高：

Pattern p = Pattern.compile("\\d+");
Matcher m = p.matcher("");
for (String s : myStringList) {
    if ( m.reset(s).matches() ) {
        doSomething();
    }
}

如果您熟悉 .NET 正则表达式，您可能想知道 Java 的 compile() 方法是否与 .NET 的 RegexOptions.Compiled 修饰符有关；答案是不。 Java 的Pattern.compile() 方法仅相当于.NET 的Regex 构造函数。当您指定 Compiled 选项时：

Regex r = new Regex(@"\d+", RegexOptions.Compiled); 

...它将正则表达式直接编译为 CIL 字节码，使其执行速度更快，但在前期处理和内存使用方面付出了巨大的代价——将其视为正则表达式的类固醇。 Java 没有等价物；由String#matches(String) 在幕后创建的模式与您使用Pattern#compile(String) 显式创建的模式之间没有区别。

（编辑：我最初说所有 .NET Regex 对象都被缓存，这是不正确的。从 .NET 2.0 开始，自动缓存仅发生在 Regex.Matches() 之类的静态方法中，而不是在您直接调用 Regex 构造函数时发生。@987654321 @)

Answer 6

编译解析正则表达式并构建内存表示。与匹配相比，编译的开销很大。如果您重复使用模式，缓存编译后的模式将获得一些性能。

Answer 7

当您编译@​​987654321@ 时，Java 会进行一些计算以更快地在Strings 中找到匹配项。 （构建正则表达式的内存表示）

如果您要多次重复使用Pattern，您会发现与每次创建一个新的Pattern 相比，性能会大幅提升。

在只使用一次Pattern 的情况下，编译步骤看起来就像是多出一行代码，但实际上在一般情况下它会很有帮助。