大家好，我是云扬～ 最近在项目中发现很多小伙伴对 Java 字符串拼接的用法还存在一些误区，比如循环中滥用+号操作符导致性能问题，或者不清楚不同拼接方式的适用场景。今天就来系统梳理一下 Java 中字符串拼接的几种核心方法，从底层原理到代码实战，帮大家彻底搞懂这个基础却关键的知识点。

一、+号操作符：语法糖的底层真相

我们最常用的字符串拼接方式就是+号，比如：

String str = "Hello" + " World" + "!";
System.out.println(str); // 输出：Hello World!

但很多人不知道，+号其实是 Java 提供的语法糖，编译器会在编译阶段对其进行优化。比如上面的代码，编译后会被转换成：

String str = new StringBuilder().append("Hello")
                                .append(" World")
                                .append("!").toString();

这就是为什么直接使用+号拼接字符串时，性能并没有想象中那么差 —— 因为编译器已经帮我们优化成了StringBuilder的append操作。

不过有个特殊情况：如果+号连接的两个操作数都是编译时常量，编译器会直接在编译阶段完成拼接，比如：

// 编译时常量拼接，直接优化为字符串常量"11"
String numStr = 11 + "";
// 等同于 String numStr = "11";

这种情况不会创建StringBuilder对象，效率更高。

二、循环拼接：+号 vs StringBuilder.append

虽然+号在单次拼接时性能不错，但在循环体内使用会出大问题！比如下面这段代码：

// 错误示范：循环中使用+号拼接
String result = "";
for (int i = 0; i< 1000; i++) {
    result += "num" + i; // 每次循环都会创建新的StringBuilder对象
}

为什么说这是错误的？因为每次执行result += ...时，Java 都会创建一个新的StringBuilder对象，拼接后再转成String。循环 1000 次就会创建 1000 个StringBuilder和String对象，不仅占用大量内存，还会触发频繁的垃圾回收（GC），严重影响性能。

正确写法：在循环外部创建StringBuilder对象，循环内仅调用append方法：

// 正确示范：循环中使用StringBuilder.append
StringBuilder sb = new StringBuilder();
for (int i = 0; i< 1000; i++) {
    sb.append("num").append(i); // 仅创建1个StringBuilder对象
}
String result = sb.toString();

这样只会创建一个StringBuilder对象，所有拼接操作都在同一个对象中进行，性能大幅提升。

三、StringBuilder.append源码深度解析

为什么append方法效率这么高？我们来看一下其底层实现（基于 JDK 11）：

// StringBuilder的append方法（继承自AbstractStringBuilder）
public StringBuilder append(String str) {
    super.append(str);
    return this;
}

// 父类AbstractStringBuilder的核心实现
public AbstractStringBuilder append(String str) {
    if (str == null) {
        return appendNull(); // 处理null值，转为字符串"null"
    }
    int len = str.length();
    ensureCapacityInternal(count + len); // 扩容检查
    str.getChars(0, len, value, count); // 复制字符到目标数组
    count += len; // 更新字符长度
    return this;
}

关键步骤拆解：

1. null 值处理：如果拼接的字符串是null，会自动转为 “null”（这和+号操作符的行为一致）；
2. 扩容检查：StringBuilder内部用字符数组value存储字符串，ensureCapacityInternal会判断拼接后的长度是否超过数组容量，如果超过则进行扩容（默认扩容为原容量的 2 倍 + 2）；
3. 字符复制：通过str.getChars直接将拼接字符串的字符复制到目标数组，避免创建新对象；
4. 长度更新：直接修改count变量记录当前字符串长度，无需额外计算。

这种基于数组的直接操作，是StringBuilder高效的核心原因。

四、其他拼接方式：concat、join与StringUtils.join

除了上述两种核心方式，Java 还提供了其他几种实用的拼接方法，我们来逐一分析：

1. String.concat方法

concat方法是String类自带的拼接方法，用法如下：

String str1 = "Hello";
String str2 = "World";
String result = str1.concat(" ").concat(str2); // 输出：Hello World

其源码实现比较简单：

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this; // 拼接空字符串时，直接返回原对象
    }
    int len = value.length;
    char[] buf = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

优缺点：

• 优点：拼接空字符串时效率极高（直接返回原对象，无需创建新字符串）；
• 缺点：
  • 遇到null会抛出NullPointerException（+号和StringBuilder不会）；
  • 多次拼接时会创建大量中间字符串对象，性能不如StringBuilder。

2. String.join方法（Java 8+）

String.join是 Java 8 新增的静态方法，支持用指定分隔符拼接字符串数组或集合：

// 拼接字符串数组
String[] arr = {"Java", "String", "Concatenation"};
String result1 = String.join("-", arr); // 输出：Java-String-Concatenation

// 拼接集合
List<String> list = Arrays.asList("Spring", "Boot", "2.x");
String result2 = String.join(" ", list); // 输出：Spring Boot 2.x

其底层实现是通过StringJoiner（本质也是基于StringBuilder），源码简化如下：

public static String join(CharSequence delimiter, CharSequence... elements) {
    StringJoiner joiner = new StringJoiner(delimiter);
    for (CharSequence cs : elements) {
        joiner.add(cs);
    }
    return joiner.toString();
}

适用场景：需要给多个字符串添加统一分隔符时（比如拼接 URL 参数、日志信息），代码简洁且易读。

3. StringUtils.join方法（Apache Commons Lang3）

如果项目中引入了Apache Commons Lang3依赖，推荐使用StringUtils.join方法，它解决了null值处理问题：

// 引入依赖（Maven）
<!-- Source: https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.20.0</version>
    <scope>compile</scope>
</dependency>

// 代码示例：无需担心null值
String str1 = "Hello";
String str2 = null;
String str3 = "World";
String result = StringUtils.join(str1, str2, str3); // 输出：HelloWorld
// 带分隔符的拼接
String resultWithDelim = StringUtils.join(new String[]{str1, str2, str3}, "-"); // 输出：Hello-World

StringUtils.join的底层也是使用StringBuilder，并且会自动忽略null值，避免空指针异常，是实际项目中非常常用的工具方法。

五、实战优化建议总结

1. 单次拼接：直接使用+号（编译器优化为StringBuilder，代码简洁）；
2. 循环拼接：必须使用StringBuilder.append（避免创建大量中间对象）；
3. 多字符串分隔拼接：使用String.join（Java 8+）或StringUtils.join（需引入依赖）；
4. 拼接空字符串：优先使用concat方法（效率最高）；
5. 处理 null 值：使用StringUtils.join（自动忽略 null）或手动判断（str == null ? "" : str）。

最后

字符串拼接看似简单，但背后涉及编译器优化、内存分配、性能损耗等多个知识点。掌握不同拼接方式的底层原理和适用场景，能帮助我们写出更高效、更健壮的代码。如果大家有其他关于字符串处理的疑问，欢迎在评论区留言讨论～