本文深入解析 Java String 不可变性的设计原因，包括字符串常量池内存共享、安全性防止篡改、线程安全无需锁竞争以及作为 HashMap Key 的 hashCode 缓存优势。对比了 String、StringBuilder 和 StringBuffer 在可变性、线程安全和性能上的差异，指出高频修改场景应使用 StringBuilder 并预分配容量。此外介绍了 Java 8 StringJoiner 在处理分隔符拼接时的优雅用法及适用场景。
String 设计成不可变的是 Java 最重要的架构决策之一，涉及性能、安全、并发三大领域。
String s1 = "hello"; // 放入常量池
String s2 = "hello"; // 直接引用常量池的同一个对象
// 如果 String 可变：
s2.replace('h', 'H'); // 会导致 s1 也变成 "Hello"！灾难！
public class StringPoolDemo {
public static void main(String[] args) {
// 【机制】字符串字面量会自动入池（intern）
String s1 = "java"; // 在常量池创建 "java"
String s2 = "java"; // 【复用】s2 指向常量池已存在的对象
System.out.println(s1 == s2); // true（同一对象）
// 【不可变的必要性】假设 String 可变，看会发生什么：
// 假设有代码：s2.replace('j', 'J') 修改了原对象
// 结果：s1 也变成了 "Java"！因为指向同一内存地址！
// 这将导致：常量池混乱，所有引用 "java" 的地方都受影响
// 【实际验证】String 的不可变性保证了安全性
String s3 = s1.toUpperCase(); // 创建新对象 "JAVA"，s1 仍然是 "java"
System.out.println(s1); // 输出 "java"（原对象未被篡改）
System.out.println(s3); // 输出 "JAVA"（新对象）
}
}
针对性体现：常量池是 Java 的享元模式（Flyweight）实现，要求对象必须不可变才能安全共享。如果可变，共享一个对象被修改，所有引用者都会受影响。
// 网络连接、文件路径、密码等都用 String 存储
String password = "admin123"; // 假设这是从配置文件读取的密码
// 如果 String 可变，攻击者可以：
// password.replace('a', 'b'); // 直接改掉密码，绕过验证！
public class SecurityDemo {
// 【场景 1】网络编程中的主机名检查
public void connectToHost(String hostname) {
// 安全检查：只允许连接特定域名
if (!hostname.endsWith(".trusted.com")) {
throw new SecurityException("不可信主机");
}
// 【风险】如果 String 可变，检查后被篡改：
// 假设攻击者在检查后把 hostname 改为 "evil.com"
// 实际连接的却是恶意网站！
// 实际执行连接
System.out.println("连接到：" + hostname);
}
// 【场景 2】类加载器中的类名
public void loadClass(String className) {
// Java 的类加载机制依赖字符串不可变
// 如果 className 在中间被篡改，可能加载恶意类
}
// 【场景 3】数据库连接字符串
public void connectDB(String url) {
// jdbc:mysql://localhost:3306/mydb
// 如果可变，连接字符串被篡改，可能连接到钓鱼数据库
}
}
针对性体现：Java 的安全机制（类加载器、安全管理器、网络连接）大量依赖 String 作为参数。如果 String 可变，安全检查通过后对象被修改，会产生 TOC/TOU（Time-Of-Check to Time-Of-Use）攻击漏洞。
// String 可以在多线程间自由共享，无需同步
String config = "max_connections=100";
// 多个线程同时读取，无需加锁，不会出错
// 因为没人能修改它，不存在并发修改问题
public class ThreadSafetyDemo {
// 【共享配置】所有线程共享同一个 String 对象
private static final String CONFIG = "timeout=5000";
public static void main(String[] args) {
// 启动 10 个线程同时读取
for (int i = 0; i < 10; i++) {
new Thread(() -> {
// 【安全】无需 synchronized，无需 volatile
// 因为 String 不可变，不存在"读到一半被修改"的问题
System.out.println(Thread.currentThread().getName() + ": " + CONFIG);
}).start();
}
}
}
针对性体现：不可变对象天然具备原子性可见性，是最安全的并发共享对象。不需要 synchronized 关键字，不需要 volatile 修饰，JVM 保证所有线程看到的内容一致。
Map<String, Integer> map = new HashMap<>();
map.put("key", 100);
// 如果 "key" 可变，修改后 hashCode 会变
// map.get("key") 就找不到值了！
public class HashKeyDemo {
public static void main(String[] args) {
Map<String, Integer> scores = new HashMap<>();
String key = "张三";
scores.put(key, 95); // 计算 key 的 hashCode 存储
// 【不可变性保证】
// key 的 hashCode 被缓存（String 内部有 hash 字段）
// 且因为不可变，hashCode 永远不变
Integer score = scores.get("张三"); // 能找到，返回 95
// 【假设 String 可变】：
// 如果 key 被修改为 "李四"，hashCode 改变
// 此时用 "张三" 去找，找不到（因为存的时候 hash 是基于"张三"）
// 这个 entry 永远丢失在 Map 中（内存泄漏）
}
}
针对性体现：String 内部缓存了 hashCode（懒加载，计算一次后存入字段）。作为 HashMap 的 key，要求 hashCode 必须稳定。如果 key 可变，修改后 hashCode 变化，就再也找不到这个键值对了。
public final class String {
private int hash; // 缓存 hashCode，默认 0
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
// 计算 hash...
hash = h; // 缓存结果
}
return h;
}
}
优势：String 被大量用作 HashMap/HashSet 的 key。因为不可变，hashCode 只需要计算一次，后续直接读取缓存，大幅提升性能。
| 特性 | 说明 | 代码体现 |
|---|---|---|
| 防御性复制 | 不需要对外部传入的 String 做保护性拷贝 | 构造函数直接 this.name = name |
| 原子性 | 状态不可变，不存在中间状态 | 多线程下读取永远是完整值 |
| 易于测试 | 没有副作用，输入确定输出就确定 | 单元测试无需考虑状态变化 |
| 可安全发布 | 无需同步即可安全发布到多线程 | public static final String CONFIG = "xxx" |
**String 设计成不可变，是 Java 的"保守安全策略"：**为了省内存（常量池共享）、为了保安全（防止被篡改绕过权限检查）、为了并发快（天然线程安全无需加锁）、为了当钥匙（HashMap 的 key 必须稳定）
代价：每次修改都创建新对象，产生短期垃圾。但 JVM 对 String 的垃圾回收优化极好，且常量池复用抵消了大部分开销，利远大于弊。
以下是三者的底层实现差异和性能优化策略：
| 维度 | String | StringBuilder | StringBuffer |
|---|---|---|---|
| 可变性 | ❌ 不可变（final） | ✅ 可变 | ✅ 可变 |
| 线程安全 | ✅ 安全（只读） | ❌ 不安全 | ✅ 安全（synchronized） |
| 存储结构 | final byte[]（JDK9+） | byte[]（可扩容） | byte[]（可扩容） |
| 默认容量 | 内容长度 | 16 字符 | 16 字符 |
| 扩容策略 | 无（每次 new） | 2n+2 | 2n+2 |
| 适用场景 | 常量、少修改 | 单线程大量修改 | 多线程大量修改 |
源码本质（JDK9+）：
public final class String {
private final byte[] value; // final 修饰，一旦创建不可变
private final byte coder; // LATIN1(0) 或 UTF16(1)
}
性能灾难示例：
// 循环 10000 次拼接（绝对禁止！）
String result = "";
for (int i = 0; i < 10000; i++) {
result += i; // 每次创建 2 个对象（StringBuilder + String）
}
// 共产生约 20000 个临时对象，触发 Young GC 频繁
优化原理：
+ 操作符在循环中会被编译器优化为：
StringBuilder sb = new StringBuilder();
sb.append(result).append(i);
result = sb.toString(); // 每次 toString() 都 new String()
底层结构：
// AbstractStringBuilder 源码（StringBuilder 的父类）
byte[] value; // 非 final，可扩容
int count; // 实际使用长度
扩容策略（源码逻辑）：
private int newCapacity(int minCapacity) {
// 新容量 = 旧容量 * 2 + 2
int newCapacity = (value.length << 1) + 2;
if (newCapacity - minCapacity < 0) {
newCapacity = minCapacity; // 如果还不够，直接按需求扩
}
return newCapacity;
}
性能优化点——预分配容量：
// ❌ 低效：频繁扩容（10 次扩容，数组拷贝开销大）
StringBuilder sb = new StringBuilder(); // 默认 16
for (int i = 0; i < 1000; i++) {
sb.append("abcdefghijklmnopqrstuvwxyz"); // 容量不够时扩容、拷贝数组
}
// ✅ 高效：预分配足够空间（只需 1 次分配）
StringBuilder sb = new StringBuilder(26000); // 预估总长度
// 避免扩容带来的 System.arraycopy 开销
JDK9+ 的 Compact Strings 优化：
同步机制源码：
// StringBuffer 的每个方法都加了 synchronized（对象锁）
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str); // 调用父类 AbstractStringBuilder
return this;
}
性能测试对比（单线程环境，拼接 100 万次）：
多线程陷阱：
虽然 StringBuffer 线程安全，但在高并发写场景下，synchronized 会导致：
现代替代方案（Java 5+）：
使用 java.util.concurrent 包或局部变量 StringBuilder（每个线程一个，无竞争）：
// 多线程环境下，每个线程有自己的 StringBuilder（ThreadLocal）
ThreadLocal<StringBuilder> builder = ThreadLocal.withInitial(
() -> new StringBuilder(1000)
);
// ❌ 错误：SQL 注入风险 + 性能差
// 应使用 PreparedStatement 而非字符串拼接
StringBuilder sql = new StringBuilder("SELECT * FROM user WHERE id IN (");
List<Integer> ids = Arrays.asList(1, 2, 3);
for (int i = 0; i < ids.size(); i++) {
if (i > 0) sql.append(",");
sql.append(ids.get(i));
}
sql.append(")");
// 一次性提交，减少网络往返
// 预估容量 = 平均字段长度 × 字段数 × 1.5（留余量）
int capacity = avgFieldLength * fieldCount * 3 / 2;
StringBuilder json = new StringBuilder(capacity);
json.append("{");
for (Field field : fields) {
json.append("\"").append(field.name).append("\":")
.append("\"").append(field.value).append("\",");
}
json.setCharAt(json.length() - 1, '}'); // 技巧：替换最后一个逗号
// 使用 StringBuilder 局部变量，避免 StringBuffer 的锁
public void log(String msg) {
// 每个线程独立，无需同步
StringBuilder sb = new StringBuilder(256);
sb.append(LocalDateTime.now())
.append(" [")
.append(Thread.currentThread().getName())
.append("] ")
.append(msg);
asyncQueue.offer(sb.toString()); // 只在此处转为 String
}
+ 拼接字符串（编译器优化也救不了，每次循环都创建 Builder）。new StringBuilder(预估长度) 比默认 16 字符快 30% 以上。一句话总结： 高频修改场景下，StringBuilder + 预分配容量 是性能最优解；StringBuffer 已过时（除遗留代码）；String 只读场景专用。
StringJoiner 是 Java 8 为"分隔符拼接"场景量身定制的利器，完美解决了 StringBuilder 处理分隔符时"开头多一个逗号"或"结尾多一个逗号"的痛点。
// 拼接 SQL: SELECT * FROM user WHERE id IN (1,2,3,4,5)
List<Integer> ids = Arrays.asList(1, 2, 3, 4, 5);
StringBuilder sql = new StringBuilder("SELECT * FROM user WHERE id IN (");
for (int i = 0; i < ids.size(); i++) {
if (i > 0) sql.append(","); // 【痛点】每次都要判断是不是第一个
sql.append(ids.get(i));
}
sql.append(")"); // 结果：SELECT * FROM user WHERE id IN (1,2,3,4,5)
StringJoiner joiner = new StringJoiner(",", "(", ")"); // 分隔符，前缀，后缀
ids.forEach(id -> joiner.add(String.valueOf(id)));
String sql = "SELECT * FROM user WHERE id IN " + joiner; // 结果：SELECT * FROM user WHERE id IN (1,2,3,4,5)
优雅之处：
()、[]、{} 时无需手动拼接add()，返回空字符串（或自定义 emptyValue）public String buildInCondition(List<String> values) {
if (values == null || values.isEmpty()) {
return "IN ()"; // 空值处理
}
StringJoiner joiner = new StringJoiner("', '", "('", ")'"); // 分隔符：', ' 前缀：(' 后缀：')
values.forEach(joiner::add);
return "IN " + joiner.toString(); // 输出：IN ('Apple', 'Banana', 'Cherry')
}
// 使用 List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");
// String condition = buildInCondition(fruits); // 生成：IN ('Apple', 'Banana', 'Cherry')
List<String> tags = Arrays.asList("Java", "Python", "Go");
StringJoiner jsonArray = new StringJoiner("\", \"", "[\"", "\"]"); // 分隔符：", " 前缀：[" 后缀："]
// 注意：前缀和后缀可以包含任意字符，包括引号
tags.forEach(jsonArray::add);
System.out.println(jsonArray); // 输出：["Java", "Python", "Go"]
StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.setEmptyValue("[]"); // 如果没有 add 任何元素，返回 []
// 场景 A：有数据
joiner.add("A").add("B");
System.out.println(joiner); // [A, B]
// 场景 B：无数据（清空后）
joiner = new StringJoiner(", ", "[", "]");
joiner.setEmptyValue("[]");
System.out.println(joiner); // [] 而不是 ""
| 特性 | StringJoiner | StringBuilder |
|---|---|---|
| 分隔符处理 | ✅ 自动处理，无多余分隔符 | ❌ 需手动判断 if (i>0) |
| 前缀/后缀 | ✅ 构造函数指定，自动包裹 | ❌ 需手动 append 前后 |
| 空集合处理 | ✅ setEmptyValue() 优雅处理 | ❌ 需手动判断 if empty |
| 性能 | 稍慢（内部也用 StringBuilder） | 稍快（直接操作） |
| 适用场景 | 有固定格式的列表拼接 | 无固定格式的任意拼接 |
性能说明：
StringJoiner内部也是用StringBuilder实现的，所以性能差距极小（几次方法调用开销），但代码可读性提升巨大。
Java 8 以后，配合 Stream 使用更加函数式：
// 方式 1：Collectors.joining（最简洁）
String result = ids.stream()
.map(String::valueOf)
.collect(Collectors.joining(", ", "(", ")));
// 效果等同于 StringJoiner
// 方式 2：String.join（简单场景）
String csv = String.join(", ", names); // 无前后缀，纯分隔符
// 方式 3：StringJoiner（需要前后缀时）
StringJoiner joiner = new StringJoiner(", ", "前缀", "后缀");
names.forEach(joiner::add);
StringJoiner 是"带格式的 StringBuilder"，专门解决"用逗号/分号连接列表，并加前后括号"的场景。写 SQL 的 IN 条件、构造 JSON 数组、生成 CSV 时，比 StringBuilder 少写 50% 的代码，且永远不会出现 (,1,2,3) 这种低级错误。
StringJoiner 专为分隔符拼接场景设计，能自动处理分隔符、前缀/后缀，避免 StringBuilder 手动判断分隔符的冗余代码；StringJoiner 支持 setEmptyValue() 优雅处理空集合场景，无需额外的空值判断逻辑；StringJoiner 底层基于 StringBuilder 实现，性能损耗可忽略，优先在有固定格式的列表拼接场景使用，无格式的任意拼接仍选 StringBuilder。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online