51

当我比较 ApacheStringUtils.replace()与Apache 的性能时，String.replace()我惊讶地发现前者快了大约 4 倍。我使用 Google 的 Caliper 框架来衡量性能。这是我的测试

public class Performance extends SimpleBenchmark {
    String s = "111222111222";

    public int timeM1(int n) {
        int res = 0;
        for (int x = 0; x < n; x++) {
            res += s.replace("111", "333").length();
        }
        return res;
    }

    public int timeM2(int n) {
        int res = 0;
        for (int x = 0; x < n; x++) {
            res += StringUtils.replace(s, "111", "333", -1).length();
        }
        return res;
    }

    public static void main(String... args) {
        Runner.main(Performance.class, args);
    }
}

输出

 0% Scenario{vm=java, trial=0, benchmark=M1} 9820,93 ns; ?=1053,91 ns @ 10 trials
50% Scenario{vm=java, trial=0, benchmark=M2} 2594,67 ns; ?=58,12 ns @ 10 trials

benchmark   us linear runtime
       M1 9,82 ==============================
       M2 2,59 =======

这是为什么？两种方法似乎都做同样的工作，StringUtils.replace()更加灵活。

4

5 回答 5

59

在现代 Java 中，情况不再如此。String.replace在从正则表达式到 StringBuilder的Java-9中得到了改进，在Java-13中得到了更多改进，直接分配目标byte[]数组，提前计算其确切大小。由于使用了内部 JDK 功能，例如分配未初始化数组的能力、访问字符串编码器的能力以及使用String避免复制的私有构造函数的能力，当前的实现不太可能被第三方实现击败。

这是我使用 JDK 8、JDK 9 和 JDK 13 进行的测试的基准测试结果（caliper:0.5-rc1; commons-lang3:3.9）

Java 8（确实慢了 4 倍）：

 0% Scenario{vm=java, trial=0, benchmark=M1} 291.42 ns; σ=6.56 ns @ 10 trials
50% Scenario{vm=java, trial=0, benchmark=M2} 70.34 ns; σ=0.15 ns @ 3 trials

benchmark    ns linear runtime
       M1 291.4 ==============================
       M2  70.3 =======

Java 9（几乎相同的性能）：

 0% Scenario{vm=java, trial=0, benchmark=M2} 99,15 ns; σ=8,34 ns @ 10 trials
50% Scenario{vm=java, trial=0, benchmark=M1} 103,43 ns; σ=9,01 ns @ 10 trials

benchmark    ns linear runtime
       M2  99,1 ============================
       M1 103,4 ==============================

Java 13（标准方法快 38%）：

 0% Scenario{vm=java, trial=0, benchmark=M2} 91,64 ns; σ=5,12 ns @ 10 trials
50% Scenario{vm=java, trial=0, benchmark=M1} 57,38 ns; σ=2,51 ns @ 10 trials

benchmark   ns linear runtime
       M2 91,6 ==============================
       M1 57,4 ==================
于 2019-10-02T10:40:31.273 回答
43

从1的源代码：java.lang.String

public String replace(CharSequence target, CharSequence replacement) {
   return Pattern
            .compile(target.toString(), Pattern.LITERAL)
            .matcher(this )
            .replaceAll(
                    Matcher.quoteReplacement(replacement.toString()));
}

String.replace(CharSequence target, CharSequence replacement)用 实现，因此，它比用和实现的2java.util.regex.Pattern慢也就不足为奇了。StringUtils.replace(String text, String searchString, String replacement)indexOfStringBuffer

public static String replace(String text, String searchString, String replacement) {
    return replace(text, searchString, replacement, -1);
}

public static String replace(String text, String searchString, String replacement, int max) {
    if (isEmpty(text) || isEmpty(searchString) || replacement == null || max == 0) {
        return text;
    }
    int start = 0;
    int end = text.indexOf(searchString, start);
    if (end == -1) {
        return text;
    }
    int replLength = searchString.length();
    int increase = replacement.length() - replLength;
    increase = (increase < 0 ? 0 : increase);
    increase *= (max < 0 ? 16 : (max > 64 ? 64 : max));
    StringBuffer buf = new StringBuffer(text.length() + increase);
    while (end != -1) {
        buf.append(text.substring(start, end)).append(replacement);
        start = end + replLength;
        if (--max == 0) {
            break;
        }
        end = text.indexOf(searchString, start);
    }
    buf.append(text.substring(start));
    return buf.toString();
}

脚注

1我链接和复制源代码的版本是 JDK 7

2我链接和复制源代码的版本是 common-lang-2.5

于 2013-04-26T05:06:38.330 回答
11

试试这个，你会发现它比 Apache 的性能非常好：

public static String replace (String source, String os, String ns) {
    if (source == null) {
        return null;
    }
    int i = 0;
    if ((i = source.indexOf(os, i)) >= 0) {
        char[] sourceArray = source.toCharArray();
        char[] nsArray = ns.toCharArray();
        int oLength = os.length();
        StringBuilder buf = new StringBuilder (sourceArray.length);
        buf.append (sourceArray, 0, i).append(nsArray);
        i += oLength;
        int j = i;
        // Replace all remaining instances of oldString with newString.
        while ((i = source.indexOf(os, i)) > 0) {
            buf.append (sourceArray, j, i - j).append(nsArray);
            i += oLength;
            j = i;
        }
        buf.append (sourceArray, j, sourceArray.length - j);
        source = buf.toString();
        buf.setLength (0);
    }
    return source;
}
于 2013-10-03T15:48:09.097 回答
6

在我与 JMH 的测试中：https ://github.com/qxo/Benchmark4StringReplace 困扰是 loukili 的方式：

java -jar target/benchmarks.jar StringReplaceBenchmark -wi 3 -i 6 -f 1 -tu ms Benchmark Mode Cnt Score Error Units StringReplaceBenchmark.test4String thrpt 6 1255.017 ± 230.012 ops/ms StringReplaceBenchmark.test4StringUtils thrpt 6 4068.229 ± 67.708 ops/ms StringReplaceBenchmark.test4fast thrpt 6 4821.035 ± 97.790 ops/ms StringReplaceBenchmark.test4lang3StringUtils thrpt 6 3186.007 ± 102.786 ops/ms

于 2017-05-29T02:19:23.853 回答
4

这是为什么？这两种方法似乎都做同样的工作。

您需要查看源代码并使用分析器进行一些认真的调查，以获得一个好的（技术）答案。

但是，一种可能的解释是，StringUtils.replace并且String.replace已经针对不同的用例进行了调整。您只看一种情况......带有一个非常小的字符串，以及一个与被替换的子字符串大小相同的替换字符串。

另一种可能的解释是 Apache 开发人员只是在调优上花费了更多时间。（不要因此责怪 Java 开发人员。他们长期以来一直在严格的人员限制下工作。在大计划中，有许多任务比性能调整更重要String.replace。）

实际上，查看源代码，Java 7 版本似乎只是在底层使用了基于正则表达式replace。相比之下，Apache 版本将竭尽全力避免复制。基于该证据，我希望两个版本之间的性能差异对于大型目标字符串相对较小。而且我怀疑 Java 7 版本在某些情况下甚至可能会更好。

（根据代码中的证据，非技术性的解释也是合理的。）

于 2013-04-26T05:00:49.833 回答