Java字符串拼接全解析：6种方式性能对比与实战指南

这是一个 Java 快速入门项目，非常适合用来练手。相关源码已上传至 GitHub，👉 点击查看 GitHub 仓库。欢迎交流指正、提交 issue。

本文全面解析Java中字符串拼接的6种主要方式，对比性能差异，并提供场景化选择建议。

一、+ 运算符

最常用的拼接方式，简洁直观：

String s = "Hello" + " " + "World";
String name = "Java";
String greeting = "Hello, " + name + "!";

底层原理 ：编译器会自动将其优化为 StringBuilder 操作（JDK 9 起改为 StringConcatFactory 动态生成拼接字节码），所以单行拼接性能不是问题。

⚠️ 陷阱 ：循环中用 + 拼接，每次循环都会创建新的 StringBuilder，产生大量临时对象：

// 反例 ❌ --- 循环中用 +
String result = "";
for (int i = 0; i < 10000; i++) {
    result += i;  // 每次循环都 new StringBuilder，极低效
}

// 正例 ✅ --- 循环中用 StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i);
}
String result = sb.toString();

二、StringBuilder / StringBuffer

类	线程安全	性能	适用场景
StringBuilder	否	快	单线程，绝大多数场景
StringBuffer	是	稍慢	多线程需要同步时

StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" ").append("World");
String result = sb.toString();

可以预分配容量以减少扩容开销：

StringBuilder sb = new StringBuilder(1024); // 预估大小，避免频繁扩容

三、String.concat()

String s = "Hello".concat(" ").concat("World");

• 内部直接创建 char[] 并复制，比 + 在少量拼接时更高效
• 适合确定只有两个字符串拼接的场景

四、String.join()

JDK 8 引入，适合用分隔符拼接多个字符串：

String result = String.join(", ", "Java", "Python", "Go");
// → "Java, Python, Go"

// 拼接集合
List<String> list = List.of("a", "b", "c");
String joined = String.join("-", list);  // "a-b-c"

五、String.format()

适合需要格式化输出的场景：

String s = String.format("姓名：%s，年龄：%d", "张三", 25);
// → "姓名：张三，年龄：25"

六、核心功能示例：高性能字符串拼接工具类

下面是一个使用 Java 实现的高性能字符串拼接工具类示例，它综合运用了多种拼接策略，适用于不同场景：

import java.util.List;
import java.util.StringJoiner;

/**
 * 高性能字符串拼接工具类
 * 提供多种拼接策略，根据场景选择最优方案
 */
public class StringConcatUtil {
    
    /**
     * 方法1：使用 StringBuilder 进行批量拼接
     * 适用于循环内拼接或已知最终长度的场景
     * @param parts 需要拼接的字符串列表
     * @return 拼接后的完整字符串
     */
    public static String concatWithStringBuilder(List<String> parts) {
        // 1. 初始化 StringBuilder，预估初始容量提高性能
        StringBuilder sb = new StringBuilder(parts.size() * 16);
        
        // 2. 遍历列表，逐个追加字符串
        for (String part : parts) {
            sb.append(part);
        }
        
        // 3. 返回最终结果
        return sb.toString();
    }
    
    /**
     * 方法2：使用 String.join() 进行分隔符拼接
     * 适用于需要固定分隔符的简单拼接场景
     * @param delimiter 分隔符
     * @param elements 需要拼接的元素数组
     * @return 用分隔符连接后的字符串
     */
    public static String concatWithJoin(String delimiter, String... elements) {
        // 1. 使用 String.join() 方法，内部优化了拼接逻辑
        return String.join(delimiter, elements);
    }
    
    /**
     * 方法3：使用 StringJoiner 进行复杂格式拼接
     * 适用于需要前缀、后缀和分隔符的格式化拼接
     * @param delimiter 分隔符
     * @param prefix 前缀
     * @param suffix 后缀
     * @param elements 需要拼接的元素列表
     * @return 格式化后的字符串
     */
    public static String concatWithStringJoiner(String delimiter, String prefix, 
                                                String suffix, List<String> elements) {
        // 1. 创建 StringJoiner 实例，指定分隔符、前缀和后缀
        StringJoiner joiner = new StringJoiner(delimiter, prefix, suffix);
        
        // 2. 遍历元素列表，逐个添加到 joiner
        for (String element : elements) {
            joiner.add(element);
        }
        
        // 3. 返回格式化后的字符串
        return joiner.toString();
    }
    
    /**
     * 方法4：使用 String.format() 进行模板化拼接
     * 适用于需要复杂格式化的场景
     * @param template 格式化模板（如 "姓名：%s，年龄：%d"）
     * @param args 模板参数
     * @return 格式化后的字符串
     */
    public static String concatWithFormat(String template, Object... args) {
        // 1. 使用 String.format() 进行模板替换
        return String.format(template, args);
    }
    
    /**
     * 主方法：演示工具类的使用
     */
    public static void main(String[] args) {
        // 示例1：使用 StringBuilder 拼接
        List<String> words = List.of("Hello", " ", "World", "!");
        String result1 = concatWithStringBuilder(words);
        System.out.println("StringBuilder 结果: " + result1);
        
        // 示例2：使用 String.join() 拼接
        String result2 = concatWithJoin("-", "2025", "06", "14");
        System.out.println("String.join() 结果: " + result2);
        
        // 示例3：使用 StringJoiner 拼接
        String result3 = concatWithStringJoiner(", ", "[", "]", 
                                                List.of("Java", "Python", "Go"));
        System.out.println("StringJoiner 结果: " + result3);
        
        // 示例4：使用 String.format() 拼接
        String result4 = concatWithFormat("用户：%s，积分：%d，状态：%s", 
                                         "张三", 1500, "活跃");
        System.out.println("String.format() 结果: " + result4);
    }
}

关键步骤说明：

1. 方法选择策略：

   • 简单拼接：使用 + 运算符或 String.concat()
   • 循环拼接：使用 StringBuilder（单线程）或 StringBuffer（多线程）
   • 分隔符拼接：使用 String.join() 或 StringJoiner
   • 格式化输出：使用 String.format()

2. 性能优化要点：

   • 预估 StringBuilder 初始容量，减少扩容次数
   • 避免在循环中使用 + 拼接字符串
   • 对于固定格式拼接，优先使用 String.join()

3. 代码可读性：

   • 为每个方法添加清晰的注释说明
   • 使用有意义的参数名和方法名
   • 提供使用示例（main 方法）

4. 扩展建议：

   • 可添加参数校验（空值检查）
   • 可支持更多拼接策略（如 Stream API）
   • 可添加性能测试和基准对比

六、总结

方式	适用场景	性能
+	单行少量拼接	✅ 编译器优化后良好
StringBuilder	循环或大量拼接	✅ 最佳
StringBuffer	多线程大量拼接	✅ 略慢于 Builder
concat()	两个字符串拼接	✅ 良好
String.join()	分隔符拼接	✅ 良好
String.format()	格式化拼接	⚠️ 较慢，胜在可读性

核心原则 ：单行拼接用 +，频繁拼接字符串时，优先使用 StringBuilder（非线程安全）或 StringBuffer（线程安全），避免产生大量中间 String 对象。