Java 正则表达式提供任何性能优势吗？

在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;
    }
}