Java StringBuilder 参数性能

Question

我遇到了以下代码：

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100000; i++) {
   String line = "foo" + Integer.toString(i) + "bar\n";
   sb.append(line);
}
System.out.print(sb.toString());

我的问题是使用以下代码会产生什么性能/内存差异：

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100000; i++) {
   sb.append("foo").append(Integer.toString(i)).append("bar\n");
}
System.out.print(sb.toString());

或者

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100000; i++) {
   sb.append(String.format("foo %i bar", i\n));
}
System.out.print(sb.toString());

我看到很多问题/答案表明使用： String cumulativeOutput = ""; ... cumulativeOutput += "foo" + Integer.toString(i) + "bar\n"; String cumulativeOutput = ""; ... cumulativeOutput += "foo" + Integer.toString(i) + "bar\n"; 是浪费的（本质上是在每次循环迭代时创建一个新的 StringBuilder ），但没有看到关于上述情况的任何直接答案。 我还看到字符串的长度很重要，并且有兴趣了解以下代码的比较方式：

StringBuilder sb = new StringBuilder();
String foo = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. ";
String bar = " Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n";
for (int i = 1000000000; i < 1000100000; i++) {
   String line = foo + Integer.toString(i) + bar;
   sb.append(line);
}
System.out.print(sb.toString());

我预计第二个循环会最快（chaining.append），但如果有一些隐藏的细节我很感兴趣。 期待看到其他人发现或知道什么！

Answer 1

你的第一个例子：

String line = "foo" + Integer.toString(i) + "bar\n";
sb.append(line);

相当于：

String line = new StringBuilder("foo").append(Integer.toString(i)).append("bar\n").toString();
sb.append(line);

你的第三个例子：

sb.append(String.format("foo %i bar", i\n));

是最浪费的，因为它相当于这样：

StringBuilder builder = new StringBuilder();
Formatter formatter = new Formatter(builder);
formatter.format("foo %i bar", i);
String value = formatter.out().toString();
sb.append(value);

您的第二个示例具有最佳性能，但使用 Integer.toString 是多余的，并创建了不必要的字符串：

sb.append("foo").append(i).append("bar\n");

在这种形式中，不会创建新对象（除非 StringBuilder 必须扩展其内部缓冲区）。

差异将非常小，通常太小而无法注意到。 可以运行 Microsoft Office 或 Doom Eternal 的现代系统可能不会因创建字符串而显着减慢速度。 即时编译器完全有可能在运行时将append(Integer.valueOf(i))转换为append(i) 。

如果您需要有关最佳实践的指导，答案是：不要在循环中使用+或String.format 。

Answer 2

1. 正如 Basil Bourque 在评论中指出的那样，您的问题带有过早优化的味道。 “哪个最有效率”的问题实际上还有第二个你没有考虑过的含义：这是最有效地利用你的时间。

2. 您实际提出的“哪个更有效”问题的答案将取决于您使用的 JVM 版本。 在某些情况下会有差异。 在其他情况下，JIT 编译器（大部分）可能会优化掉这些差异。

3. 找出哪个实际上更快以及实际差异是什么的方法是编写一个适当的微基准......并在各种硬件和各种 Java 版本上运行它。

4. 我预测前两者之间的差异将很小甚至不存在，并且format方法会更慢。

5. 大局是这 3 个版本之间的差异可能太小，在大多数现实世界的应用程序中都不重要。 您可能在浪费时间考虑这些版本中的哪个版本最快。 可能有更好的事情可以花费你的时间。

第 2 点）意味着我们不能>告诉<您哪个版本更有效。 第 3 点）意味着您需要付出努力才能获得明确的结论。 第 4) 和 5) 点意味着可能不值得努力获得明确的答案。 （尤其是因为答案只会在您测试的特定平台上针对您测试的精确示例是确定的。）

---

唯一需要指出的是，如果必须在 memory 中组装整个字符串，则使用StringBuilder是正确的。 但如果不是：

• 直接写入 BufferedWriter 或类似的东西可能更有效。 在 memory 中组装大字符串在分配大对象及其对 GC 行为和 memory 缓存等方面的影响方面存在二阶效应。

• 任何需要在堆中组装大东西的解决方案都无法扩展。 如果你正在组装的东西太大，你就会耗尽堆空间，最终耗尽物理 RAM 空间。

Answer 3

我认为编写一个显示性能的简单测试比实际编写这个问题要快一些:)

@Test
    void testBuildingString() {
        var start1 = Instant.now();

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            String line = "foo" + Integer.toString(i) + "bar\n";
            sb.append(line);
        }

        var end1 = Instant.now();
        var start2 = Instant.now();

        StringBuilder sb2 = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            sb2.append("foo").append(Integer.toString(i)).append("bar\n");
        }

        var end2 = Instant.now();
        var start3 = Instant.now();
        StringBuilder sb3 = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            sb3.append(String.format("foo %d bar", i));
        }
        var end3 = Instant.now();

        System.out.println("Time 1 = " + Duration.between(start1, end1));
        System.out.println("Time 2 = " + Duration.between(start2, end2));
        System.out.println("Time 3 = " + Duration.between(start3, end3));
    }

结果如下，和预期的一样：

Time 1 = PT0.0299933S
Time 2 = PT0.0059999S
Time 3 = PT0.2450021S

您的第二个选项是最快的，比第一个快大约 5 倍。 String.format 是最慢的。 请注意，这是 100,000 次迭代。 所以在 1 次迭代中，这将是 0.0000001s 的差异