在 Java 中，有很多方法都与操作字符串有关。 最简单的例子是 String.split("something") 方法。

现在许多这些方法的实际定义是它们都将正则表达式作为输入参数。这使得所有的构建 block 都非常强大。

现在，您将在其中许多方法中看到两种效果:

1. 每次调用该方法时，它们都会重新编译表达式。因此，它们会影响性能。
2. 我发现在大多数“现实生活”情况下，这些方法都是用“固定”文本调用的。 split 方法最常见的用法更糟糕:它通常用单个字符(通常是''、';'或'&')来调用。

因此，不仅默认方法功能强大，而且它们的实际用途似乎过于强大。在内部，我们开发了一种“fastSplit”方法，可以在固定字符串上进行拆分。我在家里写了一个测试，看看如果已知它是一个字符，我能做多快。两者都比“标准”拆分方法快得多。

所以我想知道:为什么选择现在的 Java API？ 这样做的充分理由是什么，而不是像 split(char) 和 split(String) 和 splitRegex(String) 之类的东西？？

更新:我打了几个电话，看看拆分字符串的各种方法需要多长时间。

简短的总结:它带来了大的不同!

我为每个测试用例做了 10000000 次迭代，总是使用输入

"aap,noot,mies,wim,zus,jet,teun" 

并且始终使用 ',' 或 ","作为拆分参数。

这是我在我的 Linux 系统上得到的(它是一个 Atom D510 盒子，所以有点慢):

fastSplit STRING
Test  1 : 11405 milliseconds: Split in several pieces
Test  2 :  3018 milliseconds: Split in 2 pieces
Test  3 :  4396 milliseconds: Split in 3 pieces

homegrown fast splitter based on char
Test  4 :  9076 milliseconds: Split in several pieces
Test  5 :  2024 milliseconds: Split in 2 pieces
Test  6 :  2924 milliseconds: Split in 3 pieces

homegrown splitter based on char that always splits in 2 pieces
Test  7 :  1230 milliseconds: Split in 2 pieces

String.split(regex)
Test  8 : 32913 milliseconds: Split in several pieces
Test  9 : 30072 milliseconds: Split in 2 pieces
Test 10 : 31278 milliseconds: Split in 3 pieces

String.split(regex) using precompiled Pattern
Test 11 : 26138 milliseconds: Split in several pieces 
Test 12 : 23612 milliseconds: Split in 2 pieces
Test 13 : 24654 milliseconds: Split in 3 pieces

StringTokenizer
Test 14 : 27616 milliseconds: Split in several pieces
Test 15 : 28121 milliseconds: Split in 2 pieces
Test 16 : 27739 milliseconds: Split in 3 pieces

正如您所看到的，如果您有很多“固定字符”拆分要做，这会产生很大的不同。

给大家一些见解；我目前在 Apache 日志文件和 Hadoop 领域使用 big 网站的数据。所以对我来说这些东西真的很重要:)

这里我没有考虑到垃圾收集器。据我所知，将正则表达式编译成 Pattern/Matcher/.. 会分配很多对象，这些对象需要一些时间来收集。因此，从长远来看，这些版本之间的差异可能更大……或更小。

到目前为止我的结论:

• 仅当您有大量字符串要拆分时才进行优化。
• 如果您使用正则表达式方法，如果您重复使用相同的模式，则始终预编译。
• 忘记(过时的)StringTokenizer
• 如果您想拆分单个字符，请使用自定义方法，特别是如果您只需要将其拆分为特定数量的部分(如 ... 2)。

附:我给你我所有的本土 split char 方法(根据本网站上的所有内容都属于:) 的许可)。我从来没有对它们进行过全面测试......但是。玩得开心。

private static String[]
        stringSplitChar(final String input,
                        final char separator) {
    int pieces = 0;

    // First we count how many pieces we will need to store ( = separators + 1 )
    int position = 0;
    do {
        pieces++;
        position = input.indexOf(separator, position + 1);
    } while (position != -1);

    // Then we allocate memory
    final String[] result = new String[pieces];

    // And start cutting and copying the pieces.
    int previousposition = 0;
    int currentposition = input.indexOf(separator);
    int piece = 0;
    final int lastpiece = pieces - 1;
    while (piece < lastpiece) {
        result[piece++] = input.substring(previousposition, currentposition);
        previousposition = currentposition + 1;
        currentposition = input.indexOf(separator, previousposition);
    }
    result[piece] = input.substring(previousposition);

    return result;
}

private static String[]
        stringSplitChar(final String input,
                        final char separator,
                        final int maxpieces) {
    if (maxpieces <= 0) {
        return stringSplitChar(input, separator);
    }
    int pieces = maxpieces;

    // Then we allocate memory
    final String[] result = new String[pieces];

    // And start cutting and copying the pieces.
    int previousposition = 0;
    int currentposition = input.indexOf(separator);
    int piece = 0;
    final int lastpiece = pieces - 1;
    while (currentposition != -1 && piece < lastpiece) {
        result[piece++] = input.substring(previousposition, currentposition);
        previousposition = currentposition + 1;
        currentposition = input.indexOf(separator, previousposition);
    }
    result[piece] = input.substring(previousposition);

    // All remaining array elements are uninitialized and assumed to be null
    return result;
}

private static String[]
        stringChop(final String input,
                   final char separator) {
    String[] result;
    // Find the separator.
    final int separatorIndex = input.indexOf(separator);
    if (separatorIndex == -1) {
        result = new String[1];
        result[0] = input;
    }
    else {
        result = new String[2];
        result[0] = input.substring(0, separatorIndex);
        result[1] = input.substring(separatorIndex + 1);
    }
    return result;
}

最佳答案

请注意，不需要每次都重新编译正则表达式。来自 Javadoc :

An invocation of this method of the form str.split(regex, n) yields the same result as the expression

Pattern.compile(regex).split(str, n) 

也就是说，如果你担心性能，你可以预编译模式然后重用它:

Pattern p = Pattern.compile(regex);
...
String[] tokens1 = p.split(str1); 
String[] tokens2 = p.split(str2); 
...

而不是

String[] tokens1 = str1.split(regex);
String[] tokens2 = str2.split(regex);
...

我认为这种 API 设计的主要原因是方便。由于正则表达式也包含所有“固定”字符串/字符，因此它简化了 API 以使用一种方法而不是多种方法。如果有人担心性能问题，正则表达式仍然可以如上所示进行预编译。

我的感觉(我无法用任何统计证据支持)是大多数情况 String.split() 是在性能不是问题的情况下使用的。例如。这是一次性的操作，或者与其他因素相比，性能差异可以忽略不计。 IMO 很少有在紧密循环中使用相同的正则表达式拆分字符串数千次的情况，其中性能优化确实有意义。

看到一个带有固定字符串/字符的正则表达式匹配器实现与专门针对这些的匹配器的性能比较会很有趣。差异可能不足以证明单独实现的合理性。

关于java - 为什么 Java 中的大多数字符串操作都基于正则表达式？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3362640/