String中 “+” 和 StringBuffer 中的 append 会有性能上的差别吗？

参考回答**

是的，String 中的 + 和 StringBuffer 中的 append 在性能上有明显差别。

1. String 中的 + 操作性能较低：
   • String 是不可变对象，每次使用 + 拼接字符串时，都会创建一个新的 String 对象，并复制原有的字符串内容到新对象中。
   • 如果拼接操作多次进行，尤其是在循环中，会导致大量的临时对象创建，增加内存占用并降低性能。
2. StringBuffer 的 append 性能更高：
   • StringBuffer 是可变对象，可以直接在原有的缓冲区上追加内容，而无需每次创建新的对象。
   • 因此，对于大量拼接操作，使用 StringBuffer 的 append 方法效率更高。

详细讲解与拓展

1. 为什么 String 中的 + 性能低？

String 是不可变的，每次执行 + 时，实际上会创建一个新的 String 对象，并将原有字符串的内容复制到新对象中。例如：

String str = "a";
str = str + "b";

执行过程如下：

1. 创建 "a" 的字符串对象。
2. 创建一个新字符串 "ab"，将 "a" 和 "b" 的内容合并到新对象中。
3. 原来的字符串 "a" 被丢弃。

如果在循环中频繁使用 + 进行拼接，例如：

String str = "";
for (int i = 0; i < 1000; i++) {
    str += i;
}

• 每次拼接都会生成一个新的字符串对象，总共会创建大量临时对象。
• 这些对象会被垃圾回收，但频繁分配和回收内存会显著影响性能。

2. StringBuffer 的优势

StringBuffer 是一个可变的字符串类，其内部维护一个可变的字符数组，拼接时直接在原有数组上追加内容，而无需创建新对象。

示例：

StringBuffer sb = new StringBuffer("a");
sb.append("b");

执行过程：

1. 创建一个 StringBuffer 对象，内部维护一个字符数组，初始内容为 "a"。
2. 调用 append("b") 方法，直接在原有的字符数组后追加 "b"。

由于 StringBuffer 直接操作可变的数组，因此性能远高于 String 的 + 拼接。

3. 性能测试

以下代码对比了 String 的 + 和 StringBuffer 的 append 在大量拼接操作中的性能差异：

public class Main {
    public static void main(String[] args) {
        int iterations = 100000;

        // 测试 String + 拼接
        long startTime1 = System.currentTimeMillis();
        String str = "";
        for (int i = 0; i < iterations; i++) {
            str += i;
        }
        long endTime1 = System.currentTimeMillis();
        System.out.println("String + 耗时: " + (endTime1 - startTime1) + "ms");

        // 测试 StringBuffer append
        long startTime2 = System.currentTimeMillis();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < iterations; i++) {
            sb.append(i);
        }
        long endTime2 = System.currentTimeMillis();
        System.out.println("StringBuffer append 耗时: " + (endTime2 - startTime2) + "ms");
    }
}

输出结果（根据具体环境会有差异）：

String + 耗时: 1500ms
StringBuffer append 耗时: 10ms

从结果可以看出：

• String + 的性能随着拼接次数的增加呈指数级下降。
• StringBuffer append 性能稳定且显著优于 String +。

4. StringBuilder vs StringBuffer

StringBuilder 是 StringBuffer 的非线程安全版本，但在单线程环境中性能更高。两者的选择如下：

1. 单线程：推荐使用 StringBuilder。
2. 多线程：推荐使用 StringBuffer，因为它是线程安全的。

性能对比：

• StringBuilder 和 StringBuffer 的 API 几乎相同，但由于 StringBuffer 中有同步机制（synchronized），其性能略低于 StringBuilder。

5. 编译器对 String + 的优化

在一些简单场景下，Java 编译器会对 String 的 + 进行优化。例如：

String str = "a" + "b" + "c";

编译后会优化为：

String str = "abc";

但如果拼接中包含变量：

String str = "a" + b + "c";

编译器会生成：

StringBuilder sb = new StringBuilder();
sb.append("a").append(b).append("c");
str = sb.toString();

因此，对于少量的字符串拼接，+ 的性能影响不大。但在复杂场景（如循环中频繁拼接）下，仍然建议显式使用 StringBuilder 或 StringBuffer。

6. 总结

在需要频繁拼接字符串的场景中，建议优先使用 StringBuilder 或 StringBuffer，而不是直接使用 String 的 + 操作。

shuaidi永久会员

收藏 海报挣佣金 推广链接