Java 循环拼接字符串性能对比：避免使用 + 号的最佳实践

你是不是也习惯了写这样的代码：

String str = "Hello" + ", " + "World" + "!";

或者在循环里这么干：

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

+ 号拼接字符串确实顺手，但你是否知道，在循环或高频场景下，它不仅性能可能差上千倍，还暗藏着内存和可读性的隐患？今天我们就从字节码、实际性能测试和工程实践三个角度，彻底厘清这个问题。

一、先看字节码：+ 号到底干了什么？

Java 编译器会对 String 的 + 号操作进行优化，但这个优化存在明确的边界。

先看一段简单的静态拼接代码：

public class StringConcatDemo {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String c = a + b;
    }
}

使用 javap -c 命令反编译后，你会看到以下字节码：

0: ldc           #2                  // String a
2: astore_1
3: ldc           #3                  // String b
5: astore_2
6: new           #4                  // class java/lang/StringBuilder
9: dup
10: invokespecial #5                  // Method java/lang/StringBuilder.“<init>“:()V
13: aload_1
14: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
17: aload_2
18: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
21: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
24: astore_3
25: return

可以看到，编译器将 a + b 优化成了等效的 StringBuilder 操作：

String c = new StringBuilder().append(a).append(b).toString();

这对于静态拼接没有问题，甚至比手动写 StringBuilder 更简洁。

然而，一旦将 + 号置于循环内部，情况就完全不同了：

public static void loopConcat() {
    String result = "";
    for (int i = 0; i < 1000; i++) {
        result += i;
    }
}

反编译其循环体部分，关键字节码如下：

12: new           #3                  // class java/lang/StringBuilder
15: dup
16: invokespecial #4                  // Method java/lang/StringBuilder.“<init>“:()V
19: aload_1
20: invokevirtual #5                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
23: iload_2
24: invokevirtual #6                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
27: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
30: astore_1
...

关键点在于：

• 每次循环都会 new StringBuilder()。
• 每次都会调用 append(result).append(i).toString()。
• 每次 toString() 都会创建一个新的 String 对象。

这意味着循环 1000 次，就会创建 1000 个 StringBuilder 实例和 1000 个新的 String 对象，内存分配和垃圾回收（GC）压力急剧上升。

二、性能实测：差距到底有多大？

理论分析之后，我们用代码实际测试一下。分别使用 + 号、StringBuilder、StringBuffer 进行 10 万次循环拼接：

public class StringConcatPerformanceTest {

    private static final int LOOP_COUNT = 100_000;

    // 1. 使用 + 号拼接
    public static String concatWithPlus() {
        String str = "";
        for (int i = 0; i < LOOP_COUNT; i++) {
            str += i;
        }
        return str;
    }

    // 2. 使用 StringBuilder 拼接
    public static String concatWithStringBuilder() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < LOOP_COUNT; i++) {
            sb.append(i);
        }
        return sb.toString();
    }

    // 3. 使用 StringBuffer 拼接（线程安全）
    public static String concatWithStringBuffer() {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < LOOP_COUNT; i++) {
            sb.append(i);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        long start, end;

        start = System.currentTimeMillis();
        concatWithPlus();
        end = System.currentTimeMillis();
        System.out.println(“+ 号拼接耗时: “ + (end - start) + “ms”);

        start = System.currentTimeMillis();
        concatWithStringBuilder();
        end = System.currentTimeMillis();
        System.out.println(“StringBuilder 拼接耗时: “ + (end - start) + “ms”);

        start = System.currentTimeMillis();
        concatWithStringBuffer();
        end = System.currentTimeMillis();
        System.out.println(“StringBuffer 拼接耗时: “ + (end - start) + “ms”);
    }
}

在一台普通开发机上运行，典型结果如下：

+ 号拼接耗时: 4213ms
StringBuilder 拼接耗时: 3ms
StringBuffer 拼接耗时: 5ms

结论非常直接：

• + 号在循环中比 StringBuilder 慢了约 1400 倍！
• 即使是线程安全的 StringBuffer，也比 + 号快了 800 多倍。

这还只是 10 万次循环，如果在百万、千万次的高频场景下，性能差距将是指数级增长。

三、除了性能，还有哪些隐藏问题？

1. 内存浪费与 GC 压力

正如字节码所示，循环内的 + 号拼接会产生海量的临时 String 和 StringBuilder 对象。这些对象朝生夕死，迅速成为垃圾，迫使 JVM 频繁进行垃圾回收。在高并发服务中，这会导致服务响应延迟增加、吞吐量下降，严重时可能引发长时间的 Full GC，甚至服务雪崩。

2. 可读性与维护性差

当需要拼接的变量较多时，一连串的 + 号会让代码显得冗长且结构不清晰：

String info = “用户ID:“ + userId + “, 姓名:“ + userName + “, 年龄:“ + age + “, 地址:“ + address;

相比之下，使用 StringBuilder 或格式化方法，逻辑层次更分明：

// StringBuilder 版本，链式调用更清晰
String info = new StringBuilder()
    .append(“用户ID:“).append(userId)
    .append(“, 姓名:“).append(userName)
    .append(“, 年龄:“).append(age)
    .append(“, 地址:“).append(address)
    .toString();

// 使用 String.format，意图一目了然
String info = String.format(“用户ID:%d, 姓名:%s, 年龄:%d, 地址:%s”, userId, userName, age, address);

3. 线程安全误解

有些人认为 String 不可变，所以 + 操作是线程安全的。这其实是个误区。虽然每次 + 操作产生的新 String 对象本身不可变，但result += i 这个赋值操作在多线程环境下并非原子性，可能导致数据覆盖或错乱。需要注意的是，StringBuilder 本身非线程安全，而 StringBuffer 通过 synchronized 关键字实现了线程安全，选择时需要根据场景区分。

四、不同场景下的字符串拼接正确姿势

场景 1：简单静态拼接（少量、已知的字符串）

直接使用 + 号即可，编译器会优化，代码最简洁。

String str = “Hello“ + “, “ + “World“ + “!“;

场景 2：循环或高频动态拼接

必须使用 StringBuilder，这是性能最优解。

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result = sb.toString();

性能技巧：如果能预估最终字符串的大致长度，可以在构造时指定初始容量，避免内部数组多次扩容的开销。

StringBuilder sb = new StringBuilder(1024); // 预分配 1024 字符的缓冲区

场景 3：多线程环境下拼接

使用 StringBuffer，其方法都使用 synchronized 修饰，保证了线程安全。

StringBuffer sb = new StringBuffer();
// 多个线程可以安全地调用 sb.append(...)

场景 4：复杂格式化拼接

优先使用 String.format 或 MessageFormat，可读性和可维护性最好。

String info = String.format(“用户ID:%d, 姓名:%s, 年龄:%d”, userId, userName, age);

场景 5：Java 8+ 下的集合或列表拼接

可以使用 StringJoiner 或流式 API 的 Collectors.joining()，特别适合需要特定分隔符、前缀和后缀的场景。

// StringJoiner
StringJoiner sj = new StringJoiner(“, “, “[“, “]“);
sj.add(“a“).add(“b“).add(“c“);
String result = sj.toString(); // 输出: [a, b, c]

// 集合流式拼接
List<String> list = Arrays.asList(“a“, “b“, “c“);
String result = list.stream().collect(Collectors.joining(“, “)); // 输出: a, b, c

五、总结：养成高效编码习惯

1. 静态少量拼接：用 + 号，简洁高效，享受编译器的优化。
2. 循环/高频动态拼接：必须用 StringBuilder，性能差距可达三个数量级。
3. 多线程环境：用 StringBuffer 来确保线程安全。
4. 复杂格式化：用 String.format 或 StringJoiner，提升代码可读性。

很多时候，我们依赖 + 号只是出于习惯。但在性能敏感的系统或高频执行的代码段中，这个小小的习惯可能就是潜在的瓶颈。下次编写字符串拼接代码时，不妨先判断一下场景：这是简单的静态组合，还是发生在循环或频繁调用的方法内部？如果是后者，请毫不犹豫地选择 StringBuilder。

希望本文的剖析能帮助你写出更高效、更健壮的代码。关于更多 Java 性能优化和编程实践的深度讨论，欢迎在云栈社区与其他开发者一起交流。