1. 介绍
想在 Java 中连接字符串吗？这是每个人至少会遇到一次的话题，无论是编程初学者还是专业开发者。常见的场景包括将多个名称组合成一句话、为数据库构建 SQL 语句，或输出清晰易读的日志信息。字符串拼接在许多使用场景中是不可或缺的。
然而，许多开发者会困惑于诸如“哪种方法最好？”、“+ 运算符和 StringBuilder 有什么区别？”或性能问题，例如“我的程序在拼接大量数据后突然变慢”。
本文提供了 Java 中所有主要字符串拼接方法的全面且适合初学者的解释。从简单的拼接技术到性能考量、内存效率以及现代 Java 版本中的推荐模式，我们将详细覆盖每个方面。我们还会总结 实用的最佳实践和明确的决策标准，帮助你在真实项目中选择合适的方案。
如果你想精通 Java 中的字符串拼接，或重新评估当前的实现是否最佳，请阅读至文末。你将获得可以立即在开发工作中应用的知识。
2. Java 中字符串拼接的基础
字符串拼接在 Java 编程中出现得非常频繁，但令人惊讶的是，只有少数开发者真正了解它在内部是如何工作的。让我们先回顾一下 Java 字符串的基本概念以及在拼接时需要注意的关键点。
2.1 字符串是不可变对象
Java 中的 String 类型是 不可变 的。这意味着一旦创建了字符串对象，其内容就不能被修改。
例如，考虑下面的代码：
String a = "Hello";
a = a + " World!";
虽然变量 a 最终包含了 “Hello World!”，但在内部会创建一个 新的字符串对象。原来的 “Hello” 字符串并未被修改。
这种不可变性提升了安全性并帮助防止错误，但在进行大量拼接时，可能会对内存效率和性能产生负面影响。
2.2 为什么频繁的字符串拼接会变慢？
当你使用 + 运算符反复拼接字符串时，每一次都会创建一个新的字符串对象，旧的对象则变为未使用状态。
考虑下面的循环：
String result = "";
for (int i = 0; i < 1000; i++) {
result = result + i;
}
在这种情况下，每一次迭代都会创建一个新字符串，导致内存消耗增加，性能下降。
这种现象通常被称为 “字符串拼接陷阱”，在对性能敏感的应用中尤为需要注意。
2.3 基本拼接方法概览
在 Java 中拼接字符串主要有两种方式：
+运算符（例如a + b）concat()方法（例如a.concat(b)）
两者都非常易用，但了解它们的使用模式和内部行为是编写高效 Java 代码的第一步。
3. 拼接方法对比及选择指南
Java 提供了多种字符串拼接方式，包括 + 运算符、concat() 方法、StringBuilder/StringBuffer、String.join() 与 StringJoiner，以及 String.format()。根据你的 Java 版本和具体使用场景，最佳选择会有所不同。本节将解释每种方式的特性、适用场景以及使用时的注意事项。
3.1 使用 + 运算符
最直观、最简洁的方法就是使用 + 运算符：
String firstName = "Taro";
String lastName = "Yamada";
String fullName = firstName + " " + lastName;
在 Java 8 及以后版本中，使用 + 运算符进行的字符串拼接在内部会被优化为使用 StringBuilder。然而，在循环中反复进行拼接仍需在性能方面保持警惕。
3.2 String.concat() 方法
concat() 方法是另一种基本的做法：
String a = "Hello, ";
String b = "World!";
String result = a.concat(b);
虽然简单，但如果传入 null，该方法会抛出异常，这也是它在实际应用中使用较少的原因。
3.3 使用 StringBuilder 和 StringBuffer
如果性能是首要考虑因素，应该使用 StringBuilder（在需要线程安全时使用 StringBuffer）。当拼接在循环中多次发生时，这一点尤为重要。
StringBuilder sb = new StringBuilder();
sb.append("Java");
sb.append("String");
sb.append("Concatenation");
String result = sb.toString();
3.4 String.join() 与 StringJoiner（Java 8 及以后）
当需要使用分隔符拼接多个元素时，Java 8 引入的 String.join() 和 StringJoiner 是非常便利的选择。
List<String> words = Arrays.asList("Java", "String", "Concatenation");
String joined = String.join(",", words);
3.5 String.format() 及其他方法
当需要格式化输出时，String.format() 是一个强大的选项。
String name = "Sato";
int age = 25;
String result = String.format("Name: %s, Age: %d", name, age);
3.6 对比表（使用场景与特性）
| Method | Speed | Readability | Loop Friendly | Java Version | Notes |
|---|---|---|---|---|---|
+ operator | △–○ | ◎ | × | All | Simple but not recommended in loops |
concat() | △ | ○ | × | All | Be careful with null values |
StringBuilder | ◎ | ○ | ◎ | All | Fastest for loops and large volumes |
StringBuffer | ○ | ○ | ○ | All | Recommended for multithreaded environments |
String.join() | ○ | ○ | ◎ | Java 8+ | Ideal for arrays and collections |
String.format() | △ | ○ | × | All | Best for complex formatting and readability |
3.7 选择方法的可视化指南
- 短小、临时的拼接：
+运算符 - 循环或大量数据拼接：
StringBuilder - 集合或数组：
String.join() - 多线程环境：
StringBuffer - 格式化输出：
String.format()
4. 按使用场景的最佳实践
Java 提供了多种字符串拼接方式，但了解在何种情况下使用哪种方法是提升生产力并避免实际开发中出现问题的关键。本节将阐述常见场景下的最佳做法。
4.1 对于短小、临时的拼接使用 + 运算符
如果只进行一次或少量的字符串拼接，+ 运算符已经足够。
String city = "Osaka";
String weather = "Sunny";
String message = city + " weather is " + weather + ".";
System.out.println(message);
4.2 在循环和大规模拼接中使用 StringBuilder
只要拼接是重复进行的，甚至是数十次以上，就应始终使用 StringBuilder。
StringBuilder sb = new StringBuilder();
for (String word : words) {
sb.append(word);
}
String output = sb.toString();
System.out.println(output);
4.3 对于集合和数组使用 String.join() 或 StringJoiner
当需要使用分隔符拼接数组或列表中的所有元素时，String.join() 或 StringJoiner 是理想选择。
List<String> fruits = Arrays.asList("Apple", "Banana", "Grape");
String csv = String.join(",", fruits);
System.out.println(csv);
4.4 在多线程环境中使用 StringBuffer
在并发或多线程环境中，使用 StringBuffer 而非 StringBuilder 可确保线程安全。
StringBuffer sb = new StringBuffer();
sb.append("Safe");
sb.append(" and ");
sb.append("Sound");
System.out.println(sb.toString());
4.5 处理 null 值和特殊情况
如果可能包含 null 值，String.join() 会抛出异常。为安全拼接，需要事先移除或转换 null 值。
List<String> data = Arrays.asList("A", null, "C");
String safeJoin = data.stream()
.filter(Objects::nonNull)
.collect(Collectors.joining(","));
System.out.println(safeJoin);
4.6 使用 String.format() 进行格式化和复杂输出
当您需要将多个变量组合成格式良好且易读的字符串时，String.format() 非常有用。
String name = "Tanaka";
int age = 32;
String message = String.format("Name: %s Age: %d", name, age);
System.out.println(message);
摘要
- 短期、临时的拼接 →
+运算符 - 循环或大规模拼接 →
StringBuilder - 对集合进行分隔拼接 →
String.join()或StringJoiner - 并发或线程安全环境 →
StringBuffer - 空值处理或格式化输出 → 预处理或
String.format()
5. 常见模式的实用代码示例
本节介绍 Java 中常用的字符串拼接模式，并提供具体的代码示例。这些示例可直接用于实际项目或学习场景。
5.1 使用 + 运算符的简单拼接
String city = "Osaka";
String weather = "Sunny";
String message = city + " weather is " + weather + ".";
System.out.println(message);
5.2 使用 concat() 方法
String a = "Java";
String b = "Language";
String result = a.concat(b);
System.out.println(result);
5.3 基于循环的 StringBuilder 拼接
StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) {
sb.append("No.").append(i).append(" ");
}
String output = sb.toString();
System.out.println(output);
5.4 使用 StringBuffer 的线程安全拼接
StringBuffer sb = new StringBuffer();
sb.append("Safe");
sb.append(" and ");
sb.append("Sound");
System.out.println(sb.toString());
5.5 使用 String.join() 拼接数组或列表
List<String> fruits = Arrays.asList("Apple", "Banana", "Grape");
String csv = String.join(",", fruits);
System.out.println(csv);
5.6 使用 StringJoiner 的灵活拼接
StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.add("A").add("B").add("C");
System.out.println(joiner.toString());
5.7 使用 Stream API 和 Collectors.joining() 的高级用法
List<String> data = Arrays.asList("one", null, "three");
String result = data.stream()
.filter(Objects::nonNull)
.collect(Collectors.joining("/"));
System.out.println(result);
5.8 使用 String.format() 进行格式化和拼接
String user = "Sato";
int age = 29;
String info = String.format("Name: %s, Age: %d", user, age);
System.out.println(info);
5.9 将数组转换为字符串（Arrays.toString() 示例）
int[] scores = {70, 80, 90};
System.out.println(Arrays.toString(scores));
摘要
根据使用场景选择最合适的方法，可显著提升 Java 开发的效率和质量。
6. 按 Java 版本的差异及现代趋势
Java 经过多年演进，推荐的字符串拼接方式也随之变化。本节阐述各 Java 版本的主要差异，并突出现代开发趋势。
6.1 Java 7 之前的传统观念
- 使用
+运算符被认为简单，但在循环中效率低下。 - 强烈不建议在循环中反复使用拼接，而应使用
StringBuilder。 - 在 Java 7 之前，使用
+会产生大量中间String实例，导致显著的性能下降。
6.2 Java 8 及以后版本的优化
- 从 Java 8 开始，使用
+运算符的字符串拼接在内部会被优化，编译时或运行时转换为StringBuilder操作。 - 即便如此，在循环中使用
+仍不被视为最佳实践；对于重复拼接仍推荐使用StringBuilder或String.join()。 - Java 8 引入了
String.join()和StringJoiner，使基于集合的拼接更加简便。
6.3 Java 11 / 17 及以后版本的变化与新特性
- 在 LTS（长期支持）版本（如 Java 11 和 Java 17）中，字符串拼接 API 本身并未发生显著变化，但 JVM 级别的优化持续改进，使得
+运算符的效率进一步提升。 - 此外，
String.repeat()等新方法以及增强的 Stream API 扩展了字符串创建和拼接的使用场景。
6.4 “旧常识”不再适用的时代
- 随着 Java 的演进，过去被严格禁止的技术在某些情况下已经可以接受。
- 例如，少量使用
+运算符进行拼接或在条件语句中简单使用，通常在现代 JVM 中不会引发问题。 - 但大规模拼接或在循环内部使用
+仍然存在性能风险，因此在实际开发中仍推荐使用StringBuilder。
6.5 最新趋势：在可读性与性能之间取得平衡
- 在许多现代开发环境中，代码的可读性和可维护性往往被置于过度的微优化之上。
- 常见的指导原则是：为提升可读性使用
+运算符，而在性能或复杂度成为关键时切换到StringBuilder或String.join()。 - 使用 Stream API 与
Collectors.joining()的声明式写法也在当代 Java 代码库中日益流行。
总结
字符串拼接的最佳方案会因所使用的 Java 版本而异。请避免依赖过时的建议，始终选择符合现代 Java 环境的最佳实践。
7. 常见问题解答（FAQ）
许多开发者在使用 Java 进行字符串拼接时会遇到相似的问题和陷阱。本节提供对最常见问题的简要回答。
Q1. 为什么在循环中使用 + 运算符会导致性能下降？
虽然 + 运算符使用简便且直观，但在循环内部使用时会在每次迭代中创建一个新的字符串实例。例如，在循环中进行 1,000 次字符串拼接会产生 1,000 个新对象，增加 GC 压力并降低性能。StringBuilder 是循环拼接的标准解决方案。
Q2. StringBuilder 与 StringBuffer 有何区别？
两者都是可变的字符串缓冲区，但 StringBuilder 不是线程安全的，而 StringBuffer 是线程安全的。对于单线程处理，StringBuilder 更快且更推荐。仅在需要线程安全时才使用 StringBuffer。
Q3. String.join() 能否用于包含 null 值的列表？
不能。如果传入 String.join() 的列表中包含 null，会抛出 NullPointerException。若要安全使用，请事先移除 null，或使用 Stream API 并配合 filter(Objects::nonNull)。
Q4. String.format() 会导致性能问题吗？
String.format() 提供了极佳的可读性和格式化灵活性，但其执行速度慢于简单的拼接方式。请避免在性能关键的代码路径中频繁使用；在对速度有要求时，更倾向于使用 StringBuilder 或 String.join()。
Q5. 英文资源和 Stack Overflow 的答案可靠么？
可靠。英文资源通常提供最新的基准测试和 JDK 内部实现的洞见。不过，仍需核对对应的 Java 版本和发布时间，因为较旧的答案可能已不再适用于当前的最佳实践。
Q6. 如何避免在拼接 null 值时出现错误？
concat() 和 String.join() 在遇到 null 时会抛出异常，而 + 运算符会将 null 转换为字符串 "null"。实际开发中，建议使用 Objects.toString(value, "") 或 Optional.ofNullable(value).orElse("") 来对 null 进行防护。
Q7. 最大化性能的关键检查点有哪些？
- 使用
StringBuilder进行循环和大规模拼接 - 使用
String.join()或Collectors.joining()处理数组和集合 - 首先保证代码简洁且正确，然后根据基准测试进行优化
- 关注 JVM 和 JDK 的最新动态
8. 摘要与推荐决策流程图
本文从基础到高级使用场景，系统阐述了 Java 字符串拼接的方式，包括性能考量和不同版本的差异。下面给出简明的总结和实用的决策指南。
8.1 关键要点
+运算符 适用于小规模、临时的拼接以及代码可读性要求高的场景。不适合在循环或大规模处理中使用。- StringBuilder 对于重复或大规模拼接是必备工具，是实际开发中的事实标准。
- StringBuffer 仅在需要线程安全时才使用。
- String.join() / StringJoiner 适合对数组、列表和集合进行带分隔符的拼接，是 Java 8 及以上的现代方案。
- String.format() 适用于格式化输出和人类可读的字符串。
- Stream API / Collectors.joining() 在需要条件拼接、过滤 null 等高级场景时非常有用。
8.2 基于使用场景的方法选择流程图
如果不确定该选哪种方式，请参考以下指南：
1. Large-scale concatenation in loops → StringBuilder
2. Concatenating arrays or lists → String.join() / Collectors.joining()
3. Thread safety required → StringBuffer
4. Small, temporary concatenation → +
5. Formatting required → String.format()
6. Null handling or conditional logic → Stream API + filter + Collectors.joining()
7. Other or special cases → Choose flexibly based on requirements
8.3 实用小贴士（当你犹豫不决时）
- 若代码能够正常工作，优先考虑可读性。
- 仅在性能或安全性成为关注点时，查阅基准测试和官方文档。
- 始终根据当前使用的 JDK 版本验证推荐方案的适用性。
8.4 如何跟进未来的 Java 更新
- Oracle 官方文档 与 Java Magazine
- Stack Overflow 与 Qiita 上的最新文章
- Java Enhancement Proposal（JEP）列表
结论
Java 中没有唯一“正确”的字符串拼接方式——最佳选择取决于具体的使用场景、Java 版本以及项目规模。能够针对不同情况选取合适的方法是 Java 开发者的重要技能。请将本文的知识运用到实际编码中，以编写更高效、可维护且可靠的 Java 代码。
9. 参考文献与外部资源
为了加深理解并保持更新，请查阅可靠的文档和知名技术资源。
9.1 官方文档
- Java SE Documentation (Oracle)
- Java Platform SE 17 API Documentation
- String (Java Platform SE 17)
- StringBuilder (Java Platform SE 17)
9.2 技术文章与实用指南
- Qiita: Overview of Java String Concatenation Methods
- javadrive.jp: String Concatenation (Java Basics)
- DEXALL: String Concatenation in Java 8 and Later
- Stack Overflow: Java String Concatenation Performance and Best Practices
9.3 推荐的进一步学习资源
9.4 备注与建议
- 阅读文章时始终检查出版日期和 Java 版本。
- 在官方文档和社区讨论之间取得平衡，以辨别当前最佳实践与过时的做法。
