目录
[一、String、StringBuilder、StringBuffer 与 StringJoiner](#一、String、StringBuilder、StringBuffer 与 StringJoiner)
[1. 四种类型的区别](#1. 四种类型的区别)
[1. 为什么需要 StringBuilder?](#1. 为什么需要 StringBuilder?)
[2. 常用构造方法](#2. 常用构造方法)
[3. 常用 API](#3. 常用 API)
[4. StringBuilder 转换为 String](#4. StringBuilder 转换为 String)
[三、StringBuilder 的底层原理与扩容机制](#三、StringBuilder 的底层原理与扩容机制)
[1. 为什么 StringBuilder 可以修改字符串?](#1. 为什么 StringBuilder 可以修改字符串?)
[2. 默认容量](#2. 默认容量)
[3. 扩容机制](#3. 扩容机制)
[4. 为什么频繁扩容会影响性能?](#4. 为什么频繁扩容会影响性能?)
[5. JDK 版本差异](#5. JDK 版本差异)
[四、StringBuilder 的几个重要注意事项](#四、StringBuilder 的几个重要注意事项)
[1. StringBuilder 没有重写 equals()](#1. StringBuilder 没有重写 equals())
[2. StringBuilder 可以复用](#2. StringBuilder 可以复用)
[3. append(null) 的行为](#3. append(null) 的行为)
[1. 与 StringBuilder 的核心区别](#1. 与 StringBuilder 的核心区别)
[2. 为什么一般优先使用 StringBuilder?](#2. 为什么一般优先使用 StringBuilder?)
[3. StringBuffer 是绝对线程安全的吗?](#3. StringBuffer 是绝对线程安全的吗?)
[1. 基本使用](#1. 基本使用)
[2. 指定前缀和后缀](#2. 指定前缀和后缀)
[3. 空集合的处理](#3. 空集合的处理)
[4. String.join()](#4. String.join())
[5. 与 Stream 结合](#5. 与 Stream 结合)
[1. String 的 + 不一定慢](#1. String 的 + 不一定慢)
[2. 循环中反复拼接](#2. 循环中反复拼接)
[3. 三种拼接工具如何选择?](#3. 三种拼接工具如何选择?)
[八、Java 后端常见实战场景](#八、Java 后端常见实战场景)
[案例五:拼接 SQL 的注意事项](#案例五:拼接 SQL 的注意事项)
[Q1:StringBuilder 和 String 有什么区别?](#Q1:StringBuilder 和 String 有什么区别?)
[Q2:StringBuilder 和 StringBuffer 有什么区别?](#Q2:StringBuilder 和 StringBuffer 有什么区别?)
[Q3:StringBuilder 默认容量是多少?](#Q3:StringBuilder 默认容量是多少?)
[Q4:StringBuilder 为什么比循环使用 String + 通常更高效?](#Q4:StringBuilder 为什么比循环使用 String + 通常更高效?)
[Q5:StringBuilder 的 equals() 比较内容吗?](#Q5:StringBuilder 的 equals() 比较内容吗?)
[Q6:StringJoiner 和 StringBuilder 有什么区别?](#Q6:StringJoiner 和 StringBuilder 有什么区别?)
[Q7:StringBuilder 是不是线程不安全,所以后端不能使用?](#Q7:StringBuilder 是不是线程不安全,所以后端不能使用?)
[Q8:StringBuilder.toString() 后修改 Builder,会影响之前的 String 吗?](#Q8:StringBuilder.toString() 后修改 Builder,会影响之前的 String 吗?)
[十、Java 与 JavaScript 对比](#十、Java 与 JavaScript 对比)

本文系统整理 Java 中三种重要的字符串处理工具:
StringBuilder、StringBuffer和StringJoiner,重点记录可变字符串机制、常用 API、容量扩展、线程安全、字符串拼接性能及实际业务场景。
一、String、StringBuilder、StringBuffer 与 StringJoiner
Java 中 String 对象不可变。当我们需要频繁修改字符串内容时,可以考虑使用可变字符串处理工具。
1. 四种类型的区别
| 类型 | 特点 | 线程安全 | 适用场景 |
|---|---|---|---|
| String | 字符串不可变 | 对象内容不可变 | 普通字符串存储和操作 |
| StringBuilder | 字符序列可变 | 不保证 | 单线程或局部字符串拼接 |
| StringBuffer | 字符序列可变,方法提供同步保障 | 单次操作有同步保障 | 需要共享可变字符序列的场景 |
| StringJoiner | 按分隔符拼接字符串 | 不保证 | 集合、列表、格式化输出 |
核心区别:
-
String:适合普通字符串操作。 -
StringBuilder:适合频繁追加、删除、修改字符串。 -
StringBuffer:提供同步机制的可变字符串类。 -
StringJoiner:专门处理分隔符、前缀和后缀。
对于大多数普通 Java 后端业务,优先掌握 StringBuilder 和 StringJoiner。
二、StringBuilder:可变字符串
StringBuilder 是 Java 提供的可变字符序列类。
1. 为什么需要 StringBuilder?
先看普通的 String 拼接:
java
String str = "Hello";
str = str + " Java";
str = str + " Backend";
System.out.println(str);
// Hello Java Backend
由于 String 不可变,拼接操作不会修改原来的 String 对象,而是产生新的字符串结果。
如果在循环中不断拼接:
java
String str = "";
for (int i = 0; i < 10000; i++) {
str += i;
}
这种写法可能产生大量临时字符串处理开销,尤其是随着结果越来越长,重复拼接的成本可能持续增加。
解决方式:使用 StringBuilder。
java
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
sb.append(i);
}
String result = sb.toString();
StringBuilder 可以在同一个可变对象中累积字符内容,避免每次追加都必须创建新的 String 结果。
2. 常用构造方法
java
// 创建空 StringBuilder
StringBuilder sb1 = new StringBuilder();
// 指定初始容量
StringBuilder sb2 = new StringBuilder(100);
// 根据已有字符串创建
StringBuilder sb3 = new StringBuilder("Java");
需要注意:
java
StringBuilder sb = new StringBuilder(100);
System.out.println(sb.length()); // 0
System.out.println(sb.capacity()); // 100
length 与 capacity 的区别:
-
length():当前字符序列的长度。 -
capacity():当前内部缓冲区能够容纳的字符容量。
指定容量 100,并不代表字符串已经拥有 100 个字符。
3. 常用 API
| 方法 | 作用 |
|---|---|
append() |
末尾追加内容 |
insert() |
指定位置插入内容 |
delete() |
删除指定范围 |
deleteCharAt() |
删除指定位置字符 |
replace() |
替换指定范围 |
reverse() |
反转字符序列 |
setCharAt() |
修改指定位置的 char |
length() |
获取当前长度 |
capacity() |
获取当前容量 |
setLength() |
设置字符序列长度 |
toString() |
转换为 String |
append():追加内容
java
StringBuilder sb = new StringBuilder();
sb.append("Java");
sb.append(" ");
sb.append("Backend");
System.out.println(sb); // Java Backend
StringBuilder 支持链式调用:
java
StringBuilder sb = new StringBuilder();
sb.append("Java")
.append(" ")
.append("Backend")
.append(" ")
.append(2026);
System.out.println(sb);
// Java Backend 2026
因为 append() 返回的是当前 StringBuilder 对象。
insert():插入内容
java
StringBuilder sb = new StringBuilder("JavaBackend");
sb.insert(4, " ");
System.out.println(sb);
// Java Backend
delete():删除内容
java
StringBuilder sb = new StringBuilder("Hello Java");
sb.delete(5, 10);
System.out.println(sb);
// Hello
注意:delete(start, end) 是左闭右开区间,即 [start, end)。
replace():替换内容
java
StringBuilder sb = new StringBuilder("Hello Java");
sb.replace(6, 10, "Python");
System.out.println(sb);
// Hello Python
reverse():反转字符串
java
StringBuilder sb = new StringBuilder("abcde");
sb.reverse();
System.out.println(sb);
// edcba
这也是 Java 实现字符串反转的一种简洁方式。
注意,对于包含复杂 Unicode 组合字符的文本,reverse() 不一定能够实现符合用户视觉预期的字符反转。
4. StringBuilder 转换为 String
java
StringBuilder sb = new StringBuilder("Java");
String str = sb.toString();
sb.append(" Backend");
System.out.println(sb);
// Java Backend
System.out.println(str);
// Java
重要结论:
toString() 返回的是 String 对象。
即使后续修改 StringBuilder,也不会改变已经生成的 String 内容。
三、StringBuilder 的底层原理与扩容机制
1. 为什么 StringBuilder 可以修改字符串?
StringBuilder 内部维护可扩展的字符存储空间。
当调用:
java
StringBuilder sb = new StringBuilder();
sb.append("abc");
sb.append("def");
它会将新增字符放入内部存储区域。
逻辑示意:
java
初始容量:16
[ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]
append("abc")
[a][b][c][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]
append("def")
[a][b][c][d][e][f][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]
只要剩余容量足够,就可以继续利用已有缓冲区。
如果容量不够,就需要扩容。
2. 默认容量
java
StringBuilder sb = new StringBuilder();
System.out.println(sb.capacity()); // 16
默认构造的 StringBuilder 初始容量为 16 个 UTF-16 编码单元。
3. 扩容机制
在常见的 JDK 17 HotSpot 实现中,扩容时可以近似理解为:
java
新容量 = max(旧容量 × 2 + 2, 实际所需容量)
例如:
java
StringBuilder sb = new StringBuilder(4);
System.out.println(sb.capacity()); // 4
sb.append("12345");
System.out.println(sb.capacity()); // 通常为 10
原因:
原容量为 4,追加 5 个字符时容量不足。
按照上述扩容策略:
java
4 × 2 + 2 = 10
于是扩容至 10。
注意:该扩容公式属于 JDK 实现细节,不应当作为所有 Java 实现都必须遵循的 API 保证。
4. 为什么频繁扩容会影响性能?
扩容通常需要申请更大的内部存储空间,并复制已有内容。
如果追加大量已知规模的数据,可以提前指定容量:
java
StringBuilder sb = new StringBuilder(10000);
或者:
java
sb.ensureCapacity(10000);
这样可以减少扩容次数。
但没有必要在普通业务中盲目指定很大的容量,否则可能浪费内存。
5. JDK 版本差异
Java 8 和 Java 17 在内部字符存储上存在差异:
-
JDK 8:相关实现主要使用
char[]。 -
JDK 9+:HotSpot 引入紧凑字符串相关机制,内部可以通过
byte[]和编码标记存储内容。
因此,不能简单将 StringBuilder 的容量理解为实际占用了多少字节。
容量是字符序列的逻辑容量,不等于实际内存字节数。
四、StringBuilder 的几个重要注意事项
1. StringBuilder 没有重写 equals()
java
StringBuilder a = new StringBuilder("Java");
StringBuilder b = new StringBuilder("Java");
System.out.println(a == b); // false
System.out.println(a.equals(b)); // false
这是容易出错的地方。
虽然两个 StringBuilder 的内容相同,但是 StringBuilder 没有重写 Object 的 equals() 方法。
因此,默认仍然比较对象身份。
如果需要比较内容:
java
System.out.println(
a.toString().equals(b.toString())
); // true
也可以使用:
java
System.out.println(
a.toString().contentEquals(b)
); // true
2. StringBuilder 可以复用
java
StringBuilder sb = new StringBuilder();
sb.append("Java");
System.out.println(sb); // Java
sb.setLength(0);
sb.append("Python");
System.out.println(sb); // Python
setLength(0) 可以清空当前字符序列。
但是:
清空内容并不意味着一定释放已有的内部容量。
如果 StringBuilder 曾经扩容到很大,清空后仍可能保留较大的缓冲空间。
3. append(null) 的行为
StringBuilder sb = new StringBuilder();
String name = null;
sb.append(name);
System.out.println(sb);
// null
这里输出的是文本 "null",而不是抛出空指针异常。
这是 StringBuilder 的一个特殊处理行为,不代表所有传入 null 的方法都不会抛异常。
实际开发中,如果不希望输出 "null",可以显式处理:
java
sb.append(name == null ? "" : name);
五、StringBuffer:线程安全的可变字符串
StringBuffer 与 StringBuilder 的 API 非常相似。
java
StringBuffer sb = new StringBuffer();
sb.append("Java");
sb.append(" Backend");
System.out.println(sb);
// Java Backend
1. 与 StringBuilder 的核心区别
StringBuffer 的部分核心方法使用同步机制保护。
例如,在 JDK 17 的实现中,append() 等操作提供同步保障。
可以近似理解为:
java
public synchronized StringBuffer append(String str) {
// 追加字符串
return this;
}
上面只是原理示意,并非完整的 JDK 源码。
synchronized 能够对相关操作进行同步控制。
2. 为什么一般优先使用 StringBuilder?
因为 StringBuilder 不需要为自身操作提供同步保障。
在没有共享并发访问的情况下,通常可以避免相关同步开销。
因此:
-
普通字符串处理:优先 StringBuilder。
-
确实需要多个线程共同操作同一个可变字符序列:考虑 StringBuffer 或其他同步方案。
3. StringBuffer 是绝对线程安全的吗?
需要区分单次方法调用与多个操作组成的业务逻辑。
java
if (buffer.length() > 0) {
buffer.deleteCharAt(0);
}
即使 buffer 是 StringBuffer,也不能保证整个判断和删除过程具有原子性。
因为另一个线程可能在两次方法调用之间修改内容。
结论:StringBuffer 的方法同步,不等于所有复合业务操作自动具有线程安全性。
另外,如果 StringBuilder 只是方法内部的局部变量,没有在线程之间共享,通常也不存在并发修改问题。
六、StringJoiner:字符串连接工具
StringJoiner 是 Java 8 引入的字符串连接工具类。
它主要解决:
将多个字符串按照指定分隔符连接,并支持统一前缀与后缀。
1. 基本使用
java
import java.util.StringJoiner;
StringJoiner sj = new StringJoiner(",");
sj.add("Java");
sj.add("Python");
sj.add("Vue");
System.out.println(sj);
// Java,Python,Vue
相比 StringBuilder,StringJoiner 能够自动处理中间的分隔符。
2. 指定前缀和后缀
java
StringJoiner sj = new StringJoiner(",", "[", "]");
sj.add("Java");
sj.add("Python");
sj.add("Vue");
System.out.println(sj);
// [Java,Python,Vue]
构造方法:
java
new StringJoiner(分隔符, 前缀, 后缀);
3. 空集合的处理
java
StringJoiner sj = new StringJoiner(",", "[", "]");
System.out.println(sj);
// []
可以设置空值表现:
java
sj.setEmptyValue("暂无数据");
System.out.println(sj);
// 暂无数据
注意:setEmptyValue() 只影响尚未添加元素时的结果。
4. String.join()
如果不需要逐个追加元素,可以直接使用 String.join()。
java
String result = String.join(
",",
"Java",
"Python",
"Vue"
);
System.out.println(result);
// Java,Python,Vue
也可以连接集合:
java
import java.util.List;
List<String> list = List.of("Java", "Python", "Vue");
String result = String.join(",", list);
5. 与 Stream 结合
后端开发中经常需要将集合处理后连接成字符串。
java
import java.util.List;
import java.util.stream.Collectors;
List<String> names = List.of("Tom", "Jack", "Lucy");
String result = names.stream()
.map(String::toUpperCase)
.collect(Collectors.joining(","));
System.out.println(result);
// TOM,JACK,LUCY
还可以指定前缀和后缀:
java
String result = names.stream()
.collect(Collectors.joining(",", "[", "]"));
System.out.println(result);
// [Tom,Jack,Lucy]
实际开发选择:
-
已有集合,直接连接:
String.join()。 -
需要先筛选、转换,再连接:
Collectors.joining()。 -
需要逐个添加、控制分隔符和格式:
StringJoiner。
对于前端开发者,可以将它与 JavaScript 的 Array.join() 类比理解。
七、字符串拼接的性能分析
1. String 的 + 不一定慢
java
String name = "Tom";
String message = "Hello " + name;
这种简单拼接完全没有必要刻意替换为 StringBuilder。
因为现代 Java 编译器和 JVM 已经对字符串拼接进行了大量优化。
JDK 9 及之后,常见字符串拼接可以借助 invokedynamic 和 StringConcatFactory 实现。
因此:
不能简单地说所有 String 的 + 都比 StringBuilder 慢。
2. 循环中反复拼接
需要注意的是下面这种情况:
java
String result = "";
for (int i = 0; i < 10000; i++) {
result += i;
}
每轮循环都依赖上一轮已经累积的字符串。
随着字符串增长,反复构造新结果可能带来较大的开销。
推荐:
java
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
sb.append(i);
}
String result = sb.toString();
3. 三种拼接工具如何选择?
| 使用场景 | 推荐 |
|---|---|
| 少量字符串拼接 | String + |
| 循环累计字符串 | StringBuilder |
| 多线程共享字符缓冲区 | StringBuffer 或适当同步方案 |
| 集合元素按分隔符连接 | String.join / StringJoiner |
| Stream 处理后连接 | Collectors.joining |
性能差异取决于数据量、JDK 版本、JIT 优化及实际运行环境。
如果要做严谨的性能测试,建议使用 JMH,而不是仅根据一次 System.currentTimeMillis() 的结果判断。
八、Java 后端常见实战场景
案例一:手机号脱敏
假设需要将手机号:
java
13812345678
转换成:
java
138****5678
可以使用 String 的 substring:
java
public static String maskPhone(String phone) {
if (phone == null || phone.length() != 11) {
return phone;
}
return phone.substring(0, 3)
+ "****"
+ phone.substring(7);
}
也可以使用 StringBuilder:
java
public static String maskPhone(String phone) {
if (phone == null || phone.length() != 11) {
return phone;
}
StringBuilder sb = new StringBuilder(phone);
sb.replace(3, 7, "****");
return sb.toString();
}
注意:这里只演示字符串脱敏,手机号是否有效还需要单独验证。
案例二:动态构建日志信息
java
StringBuilder sb = new StringBuilder();
sb.append("userId=").append(1001)
.append(", status=").append("success")
.append(", duration=").append(125)
.append("ms");
System.out.println(sb);
输出:
java
userId=1001, status=success, duration=125ms
不过,在实际 Spring Boot 项目中,如果使用 SLF4J 日志框架,通常更推荐参数化日志:
java
log.info(
"userId={}, status={}, duration={}ms",
userId, status, duration
);
这种写法便于统一管理日志,并避免在不需要输出该日志级别时提前进行不必要的字符串拼接。
案例三:集合数据格式化
假设数据库查询返回用户名称:
java
List<String> names = List.of(
"Tom",
"Jack",
"Lucy"
);
希望输出:
java
用户列表:[Tom, Jack, Lucy]
可以使用:
java
String result = names.stream()
.collect(Collectors.joining(", ", "[", "]"));
System.out.println("用户列表:" + result);
这类代码非常适合用于生成可读的文本摘要。
但是对于真正的 JSON 接口响应,应该使用 Jackson 等 JSON 序列化工具,而不是手动拼接 JSON 字符串。
案例四:反转字符串
java
public static String reverse(String text) {
if (text == null) {
return null;
}
return new StringBuilder(text)
.reverse()
.toString();
}
使用:
java
System.out.println(reverse("Java"));
// avaJ
这种做法适合简单字符串反转。
如果需要处理复杂 Unicode 文本,并保持用户感知字符的完整性,则需要更专业的字符分割方案。
案例五:拼接 SQL 的注意事项
StringBuilder 也可以用于构建字符串形式的 SQL。
但需要特别注意:
不要将用户输入直接拼接进 SQL 查询语句。
错误示例:
java
String sql =
"SELECT * FROM users WHERE name = '" + name + "'";
这种方式可能引发 SQL 注入风险。
推荐使用参数化查询:
java
String sql = "SELECT * FROM users WHERE name = ?";
再通过 JDBC、JdbcTemplate、MyBatis 等框架提供的参数绑定功能传入具体值。
StringBuilder 能提高字符串构建效率,但不能替代 SQL 参数化带来的安全保障。
九、核心知识点
Q1:StringBuilder 和 String 有什么区别?
String 不可变,StringBuilder 可变。
StringBuilder 适合反复追加、插入、删除字符的场景。
Q2:StringBuilder 和 StringBuffer 有什么区别?
主要区别是同步机制。
StringBuilder 不保证线程安全;StringBuffer 对相关操作提供同步保障。
普通局部字符串操作通常优先使用 StringBuilder。
Q3:StringBuilder 默认容量是多少?
默认无参构造的初始容量为 16 个字符单位。
容量不足时会自动扩容。
Q4:StringBuilder 为什么比循环使用 String + 通常更高效?
因为它可以复用内部可变存储区域,减少反复构造新字符串结果所带来的开销。
但简单拼接场景下不能认为 StringBuilder 一定更快。
Q5:StringBuilder 的 equals() 比较内容吗?
不是。
StringBuilder 没有重写 Object 的 equals(),默认比较对象身份。
比较内容可以转换为 String 后使用 equals(),或者使用 String 的 contentEquals()。
Q6:StringJoiner 和 StringBuilder 有什么区别?
StringBuilder 提供通用字符序列操作能力。
StringJoiner 专门用于按照分隔符连接字符串,并且可以指定前缀与后缀。
Q7:StringBuilder 是不是线程不安全,所以后端不能使用?
不是。
线程安全需要结合对象是否被多个线程共享来判断。
在方法内部创建并只由当前线程使用的 StringBuilder,通常不需要额外同步。
Q8:StringBuilder.toString() 后修改 Builder,会影响之前的 String 吗?
不会。
生成的 String 对象是不可变的,后续修改 StringBuilder 不会改变它的内容。
十、Java 与 JavaScript 对比
| 需求 | Java | JavaScript |
|---|---|---|
| 普通字符串拼接 | "a" + "b" |
"a" + "b" |
| 可变字符串构建 | StringBuilder | 通常使用数组累积后 join,或直接拼接 |
| 反转简单字符串 | StringBuilder.reverse() | split("").reverse().join("") |
| 数组/集合连接 | String.join() | Array.join() |
| 字符串长度 | length() | length |
| 字符串是否可变 | String 不可变 | string 不可变 |
需要注意:JavaScript 中没有 StringBuilder 的直接内置对应类。
另外,JS 引擎也会优化字符串拼接,不能认为 JavaScript 的字符串拼接一定低效。
对于有前端出身的盆友,可以重点记住:
-
Java 提供专门的可变字符串类。
-
StringBuilder 的 API 可以直接修改当前字符序列。
-
Java 的 StringJoiner 与 JS 的 Array.join() 在使用目标上比较接近。
-
Java 需要明确考虑共享可变对象的并发安全问题。
十一、总结
Java 字符串处理工具的核心知识:
-
StringBuilder:可变字符串工具,适合频繁拼接和修改。
-
StringBuffer:具有同步机制的可变字符串类。
-
StringJoiner:适合带分隔符、前缀和后缀的字符串连接。
-
容量机制:StringBuilder 通过维护可扩展缓冲区实现高效追加。
-
性能优化 :简单拼接直接使用
+,循环累积优先考虑 StringBuilder。 -
线程安全:重点关注对象是否在线程间共享,而不是只看类名称。
-
内容比较:StringBuilder 的 equals() 不会直接比较字符内容。
-
后端实践:选择适合的字符串 API,同时注意空值、参数校验及 SQL 注入风险。
最终记忆
普通字符串:String
循环拼接:StringBuilder
共享可变字符串:StringBuffer(或其他同步方案)
分隔符拼接:StringJoiner
集合拼接:String.join()
Stream 拼接:Collectors.joining()
对于 Java 后端开发,最常使用的仍然是 String 和 StringBuilder,而 StringJoiner、StringBuffer 需要根据具体场景选择。