Question

String.matches和Matcher.matches有什么区别？在表现或其他方面有什么不同吗？

Answer 1

绝对。在预编译的正则表达式上创建Matcher，而String.matches每次执行时都必须重新编译正则表达式，因此运行该行代码的频率越高，就越浪费。

Answer 2

String.matches在内部委托给Matcher.matches。

public boolean matches(String regex) {
    return Pattern.matches(regex, this);
}

public static boolean matches(String regex, CharSequence input) {
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher(input);
    return m.matches();
}

如果您正在重用Pattern对象，那么将会有一些性能优势。此外，使用Pattern / Matcher时，您可以group使用正则表达式并获取匹配的部分。

底线是，如果你有一个正则表达式，你将只使用一次，你不需要解析你的字符串来获得匹配的部分，然后使用其中任何一个。但是如果你打算对多个字符串使用相同的正则表达式，或者你需要基于正则表达式的部分字符串创建一个模式并使用它来获取匹配器。

Answer 3

出于好奇，我对时间差异进行了这个小测试。事实证明使用预编译模式的比使用String.matches方法快<5> 。

import java.util.regex.Pattern;

/**
 * @author Rajind Ruparathna
 */
public class MatchesTest {
    public static void main(String Args[]) {
        String first = "@\\{message.headers\\.?([^\\}]*)\\}";
        String second = "@\\{message.headers.wolla\\}";
        long start, end, total;
        float avg;
        int NUM_OF_ITERATIONS = 100;

        Pattern pattern = Pattern.compile(first);

        total = 0;
        start = 0;
        end = 0;
        avg = 0;

        for (int i=0; i< NUM_OF_ITERATIONS; i++) {
            start = System.nanoTime();
            pattern.matcher(second).matches();
            end = System.nanoTime();
            total = total + (end - start);
        }
        avg = total/NUM_OF_ITERATIONS;
        System.out.println("Duration pre compiled: " + avg);

        total = 0;
        start = 0;
        end = 0;
        avg = 0;

        for (int i=0; i< NUM_OF_ITERATIONS; i++) {
            start = System.nanoTime();
            first.matches(second);
            end = System.nanoTime();
            total = total + (end - start);
        }
        avg = total/NUM_OF_ITERATIONS;
        System.out.println("In place compiled: " + avg);
    }
}

输出（纳秒）：

Duration pre compiled: 4505.0

In place compiled:    44960.0

P.S。此测试是一项快速而肮脏的测试，可能不符合性能基准测试实践。如果您想获得高度准确的结果，请使用微型基准测试工具。

Answer 4

String.matches内部调用Pattern.matches(regex, str)。它的问题在于，每次调用它时都会重新编译模式，这需要花费一些资源。

最好先编译一次模式，然后尝试将其与所需的所有字符串进行匹配。我个人使用一个Patterns类，其中包含我的app中声明为final和static

的所有模式

Answer 5

Pattern.compile编译模式，以便在执行metcher.matches时，不会一次又一次地重新编译模式。 Pattern.compile预编译它。但是，如果使用string.matches，则每次执行此行时都会编译该模式。因此，最好使用Pattern.compile。

String.matches和Matcher.matches有什么区别？

5 个答案: