当前位置：码云笔记 > 后端 > Java String 拼接别再习惯用 + 号了！性能差还易出错
兰邹兰邹 后端

Java String 拼接别再习惯用 + 号了！性能差还易出错

AI 概述
本文剖析Java字符串拼接的底层原理与性能差异。普通场景下，`+`拼接会被编译器优化为`StringBuilder`，使用简单；但在循环中，`+`会反复创建对象，产生大量垃圾，造成严重性能损耗和频繁GC，实测比`StringBuilder`慢上千倍。文章还说明了其带来的内存、可读性、线程安全等隐患，并区分场景给出最佳实践：静态少量拼接用`+`，循环高频拼接用`StringBuilder`，多线程用`StringBuffer`，格式化用`String.format`，集合拼接用`StringJoiner`。
目录
文章目录隐藏
  1. 一、先看字节码：+ 号到底干了什么？
  2. 二、性能实测：差距到底有多大？
  3. 三、除了慢，还有哪些隐藏的坑？
  4. 四、正确的字符串拼接姿势推荐
  5. 五、总结

Java String 拼接别再习惯用 + 号了！性能差还易出错

在日常 Java 开发中，字符串拼接是最基础也最常用的操作。绝大多数开发者都会习惯性使用 + 号进行拼接，写法简单、上手方便，但很少有人注意到其中暗藏的性能陷阱。很多线上项目出现接口卡顿、频繁 GC、响应变慢等问题，根源往往就是不起眼的字符串拼接写法。Java 对 + 号拼接存在编译器优化边界，静态拼接看似没问题，一旦放入循环和高频场景，性能会断崖式下跌。本文结合字节码解析、实测性能对比和真实业务场景，深度拆解 Java 字符串拼接的底层原理，区分不同使用场景，给出最优编码规范，帮你避开开发中的常见误区，写出高性能、易维护的 Java 代码。

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

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

或者在循环里这么干：

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

很多人觉得 + 号拼接字符串最顺手，但实际上，在循环或高频场景下，它不仅性能差 10 倍以上，还暗藏着内存和可读性的坑。今天咱们就从字节码、实际性能测试和工程实践三个角度，把这个问题说透。

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

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 优化成了：

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;
    }
}

反编译后关键部分：

0: ldc           #2                  // String
2: astore_1
3: iconst_0
4: istore_2
5: iload_2
6: sipush        1000
9: if_icmpge     38
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
31: iinc          2, 1
34: goto          5
38: return

重点来了：

  • 每次循环都会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 进行 GC 回收。在高并发服务中，频繁 GC 会导致服务卡顿、响应时间变长，甚至引发 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 会导致数据错乱，因为每次 + 操作都不是原子的。而 StringBuilder 是非线程安全的，StringBuffer 是线程安全的，选择时需要明确场景。

四、正确的字符串拼接姿势推荐

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

直接用 + 号即可，编译器会优化成 StringBuilder，代码最简洁：

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();
// 多线程环境下安全调用 append

场景 4：复杂格式化拼接

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

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

场景 5：Java 8+ 大量字符串拼接

可以使用 StringJoiner 或 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(", "));

五、总结

总而言之，Java 字符串拼接没有绝对最好的写法，只有最合适的写法。少量静态字符串拼接，直接使用 + 号，简洁且经过编译器优化；循环迭代、海量数据拼接，优先初始化 StringBuilder，预估容量还能进一步提升性能；多线程环境锁定 StringBuffer，规避并发安全问题；格式化和集合拼接场景，推荐 String.format、StringJoiner 流式拼接，兼顾可读性与实用性。

以上关于Java String 拼接别再习惯用 + 号了！性能差还易出错的文章就介绍到这了，更多相关内容请搜索码云笔记以前的文章或继续浏览下面的相关文章，希望大家以后多多支持码云笔记。

「点点赞赏，手留余香」

赞 12 赏

给作者打赏，鼓励TA抓紧创作！

微信微信 支付宝支付宝

还没有人赞赏，快来当第一个赞赏的人吧！

声明：本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若内容造成侵权/违法违规/事实不符，请将相关资料发送至 admin@mybj123.com 进行投诉反馈，一经查实，立即处理！
重要：如软件存在付费、会员、充值等，均属软件开发者或所属公司行为，与本站无关，网友需自行判断
码云笔记 » Java String 拼接别再习惯用 + 号了！性能差还易出错

兰邹 普通

分享到：

相关推荐

发表回复