在 Java 中，当我们尝试使用正则表达式进行模式匹配时。例如获取输入字符串并使用正则表达式来确定它是否为数字。如果不是，则抛出异常。 在这种情况下，据我所知，使用正则表达式可以使代码比我们获取字符串的每个字符、检查它是否为数字以及如果不是则抛出异常更简洁。

但我假设正则表达式也能使流程更有效率。这是真的？关于这一点，我找不到任何证据。正则表达式如何在幕后进行匹配？它不也遍历字符串并逐个检查每个字符吗？

最佳答案

为了好玩，我运行了这个微型基准测试。最后一次运行(即 JVM 预热/JIT 后)的结果如下(无论如何，从一次运行到另一次运行结果相当一致):

regex with numbers 123
chars with numbers 33
parseInt with numbers 33
regex with words 123
chars with words 34
parseInt with words 733

换句话说，chars 非常高效，如果字符串是数字，Integer.parseInt 与 char 一样高效，但如果字符串不是数字，则非常慢。正则表达式介于两者之间。

结论

如果您将一个字符串解析为一个数字，并且您希望该字符串通常是一个数字，那么使用 Integer.parseInt 是最好的解决方案(高效且可读)。如果不是太频繁，当字符串不是数字时，您得到的惩罚应该很低。

ps:我的正则表达式可能不是最优的，请随时发表评论。

public class TestNumber {

    private final static List<String> numbers = new ArrayList<>();
    private final static List<String> words = new ArrayList<>();

    public static void main(String args[]) {
        long start, end;
        Random random = new Random();

        for (int i = 0; i < 1000000; i++) {
            numbers.add(String.valueOf(i));
            words.add(String.valueOf(i) + "x");
        }

        for (int i = 0; i < 5; i++) {
            start = System.nanoTime();
            regex(numbers);
            System.out.println("regex with numbers " + (System.nanoTime() - start) / 1000000);
            start = System.nanoTime();
            chars(numbers);
            System.out.println("chars with numbers " + (System.nanoTime() - start) / 1000000);
            start = System.nanoTime();
            exception(numbers);
            System.out.println("exceptions with numbers " + (System.nanoTime() - start) / 1000000);

            start = System.nanoTime();
            regex(words);
            System.out.println("regex with words " + (System.nanoTime() - start) / 1000000);
            start = System.nanoTime();
            chars(words);
            System.out.println("chars with words " + (System.nanoTime() - start) / 1000000);
            start = System.nanoTime();
            exception(words);
            System.out.println("exceptions with words " + (System.nanoTime() - start) / 1000000);
        }
    }

    private static int regex(List<String> list) {
        int sum = 0;
        Pattern p = Pattern.compile("[0-9]+");
        for (String s : list) {
            sum += (p.matcher(s).matches() ? 1 : 0);
        }
        return sum;
    }

    private static int chars(List<String> list) {
        int sum = 0;

        for (String s : list) {
            boolean isNumber = true;
            for (char c : s.toCharArray()) {
                if (c < '0' || c > '9') {
                    isNumber = false;
                    break;
                }
            }
            if (isNumber) {
                sum++;
            }
        }
        return sum;
    }

    private static int exception(List<String> list) {
        int sum = 0;

        for (String s : list) {
            try {
                Integer.parseInt(s);
                sum++;
            } catch (NumberFormatException e) {
            }
        }
        return sum;
    }
}

关于Java 正则表达式提供任何性能优势？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11875424/