💡 摘要：你是否曾在字符串拼接时遭遇性能问题？是否对String、StringBuilder和StringBuffer的选择感到困惑？
别担心，字符串处理是Java编程中最常见的操作，理解其底层机制至关重要。
本文将带你从String类的不可变性讲起，通过内存模型深入理解字符串常量池和intern()机制。
接着对比StringBuilder和StringBuffer的异同，通过性能测试数据展示它们在字符串拼接时的巨大差异。
最后通过实战案例教你如何根据场景选择最合适的字符串类。从JVM内存结构到线程安全，从性能优化到最佳实践，让你彻底掌握Java字符串处理的精髓。文末附面试高频问题解析，助你在实际开发和面试中游刃有余。
一、String：不可变的字符串
1. 不可变性的本质
定义：String类被声明为final，其内部使用final char[] value存储数据，一旦创建就不能被修改。
java
public final class String implements Serializable, Comparable<String>, CharSequence {
private final char value[]; // JDK 8及之前
private final byte[] value; // JDK 9及之后（压缩存储）
// ...
}
🌰 不可变性的体现：
java
String str = "Hello";
str.concat(" World"); // 返回新字符串，原str不变
System.out.println(str); // 输出："Hello"
String newStr = str.concat(" World"); // 需要接收返回值
System.out.println(newStr); // 输出："Hello World"
2. 字符串常量池（String Pool）
内存模型：
java
String s1 = "Java"; // 在常量池中创建
String s2 = "Java"; // 复用常量池中的对象
String s3 = new String("Java"); // 在堆中创建新对象
System.out.println(s1 == s2); // true（同一对象）
System.out.println(s1 == s3); // false（不同对象）
System.out.println(s1.equals(s3)); // true（内容相同）
内存结构：
text
栈内存 堆内存 字符串常量池
┌─────────┐ ┌─────────┐ ┌─────┐
│ s1 │ ────→│ "Java" │ ←─────── │ "Java" │
└─────────┘ └─────────┘ └─────┘
│ s2 │ ────→│ "Java" │ ←──────┐
└─────────┘ └─────────┘ │
│ s3 │ ────→│ String对象 │ │
└─────────┘ │ value → ────────┘
└─────────┘
3. intern()方法的作用
java
String s1 = new String("Java"); // 创建两个对象：常量池和堆对象
String s2 = s1.intern(); // 尝试将堆对象放入常量池
System.out.println(s1 == s2); // false（除非常量池原本没有）
二、StringBuilder：可变的字符串构建器
1. 可变性的优势
定义：StringBuilder使用可变的char[] value，支持原地修改，适合频繁的字符串操作。
java
StringBuilder sb = new StringBuilder("Hello");
sb.append(" World"); // 原地修改，不创建新对象
sb.insert(5, ",");
sb.replace(6, 11, "Java");
System.out.println(sb.toString()); // 输出："Hello,Java"
2. 内部实现与扩容机制
扩容原理：
java
// 默认容量：16字符
StringBuilder sb = new StringBuilder(); // capacity=16
// 当容量不足时，自动扩容：新容量 = 旧容量 * 2 + 2
for (int i = 0; i < 100; i++) {
sb.append(i);
if (i % 10 == 0) {
System.out.println("Length: " + sb.length() +
", Capacity: " + sb.capacity());
}
}
输出示例：
text
Length: 1, Capacity: 16
Length: 12, Capacity: 16
Length: 23, Capacity: 34 // 第一次扩容
Length: 34, Capacity: 34
Length: 45, Capacity: 70 // 第二次扩容
三、StringBuffer：线程安全的字符串构建器
1. 线程安全实现
定义：StringBuffer与StringBuilderAPI完全相同，但所有方法都使用synchronized关键字保证线程安全。
java
public final class StringBuffer extends AbstractStringBuilder {
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}
// 所有方法都是synchronized的
}
2. 性能对比
单线程环境：StringBuilder > StringBuffer（无锁开销）
多线程环境：StringBuffer更安全，但性能仍有损耗
四、性能实战测试
1. 字符串拼接性能对比
java
public class StringPerformanceTest {
public static void main(String[] args) {
final int COUNT = 100000;
// 1. 使用String拼接（最差性能）
long start1 = System.currentTimeMillis();
String result1 = "";
for (int i = 0; i < COUNT; i++) {
result1 += i; // 每次循环创建新String对象
}
long time1 = System.currentTimeMillis() - start1;
// 2. 使用StringBuilder（最佳性能）
long start2 = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < COUNT; i++) {
sb.append(i); // 原地修改
}
String result2 = sb.toString();
long time2 = System.currentTimeMillis() - start2;
// 3. 使用StringBuffer（线程安全版本）
long start3 = System.currentTimeMillis();
StringBuffer sbf = new StringBuffer();
for (int i = 0; i < COUNT; i++) {
sbf.append(i);
}
String result3 = sbf.toString();
long time3 = System.currentTimeMillis() - start3;
System.out.println("String拼接耗时: " + time1 + "ms");
System.out.println("StringBuilder耗时: " + time2 + "ms");
System.out.println("StringBuffer耗时: " + time3 + "ms");
}
}
典型输出（COUNT=100000）：
text
String拼接耗时: 3852ms
StringBuilder耗时: 5ms
StringBuffer耗时: 8ms
2. 内存占用分析
java
// 测试内存占用
Runtime runtime = Runtime.getRuntime();
runtime.gc(); // 建议GC
long memoryBefore = runtime.totalMemory() - runtime.freeMemory();
// 执行字符串操作
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100000; i++) {
sb.append("abc");
}
long memoryAfter = runtime.totalMemory() - runtime.freeMemory();
System.out.println("内存占用: " + (memoryAfter - memoryBefore) + " bytes");
五、最佳实践与使用场景
1. 如何选择？
| 场景 | 推荐类 | 理由 |
| 字符串常量、不频繁修改 | String |
利用常量池，节省内存 |
| 单线程字符串拼接 | StringBuilder |
性能最优 |
| 多线程字符串拼接 | StringBuffer |
线程安全 |
| 数据库SQL拼接 | StringBuilder |
单线程操作 |
| Web应用参数处理 | String |
通常不需要修改 |
2. 实用技巧
预分配容量：
java
// 不好的做法：默认容量可能不够，导致多次扩容
StringBuilder sb1 = new StringBuilder();
for (int i = 0; i < 1000; i++) {
sb1.append("data");
}
// 好的做法：预分配足够容量
StringBuilder sb2 = new StringBuilder(5000); // 预分配容量
for (int i = 0; i < 1000; i++) {
sb2.append("data"); // 避免扩容开销
}
链式调用：
java
String result = new StringBuilder()
.append("姓名: ").append(name)
.append(", 年龄: ").append(age)
.append(", 分数: ").append(score)
.toString();
六、总结：三大类的核心区别
| 特性 | String | StringBuilder | StringBuffer |
| 可变性 | 不可变 | 可变 | 可变 |
| 线程安全 | 是（因为不可变） | 否 | 是 |
| 性能 | 差（频繁创建对象） | 高 | 中（有锁开销） |
| 使用场景 | 字符串常量、键值 | 单线程字符串操作 | 多线程字符串操作 |
| 内存效率 | 高（常量池复用） | 中 | 中 |
🚀 记住这个原则：能用StringBuilder就不用StringBuffer，能不用String拼接就不用。
七、面试高频问题
❓1. String为什么不可变？有什么好处？
答：不可变的原因：final类 + final字符数组。
好处：
- 线程安全：天然线程安全
- 缓存哈希值：
hashCode()只计算一次 - 常量池优化：支持字符串复用
- 安全性：适合作为Map的key和网络参数
❓2. StringBuilder和StringBuffer的区别？
答：主要区别是线程安全性：
StringBuilder：非线程安全，性能更高StringBuffer：线程安全（方法加synchronized），性能稍低
在单线程环境下优先使用StringBuilder。
❓3. 字符串拼接用"+＂还是StringBuilder？
答：
- 编译期确定的常量拼接：用"+＂（编译器优化）
- 循环内的动态拼接：必须用
StringBuilder - 简单的少量拼接：可以用"+＂（可读性好）
❓4. String的intern()方法有什么作用？
答：intern()方法尝试将字符串对象放入常量池：
- 如果常量池已存在相同字符串，返回池中的引用
- 如果不存在，将当前字符串加入池中并返回引用
可以用于减少内存占用，但不要滥用。
❓5. JDK 9中String有什么变化？
答：JDK 9将char[]改为byte[]+编码标志位：
- 拉丁字符使用1字节存储，中文使用2字节
- 显著减少内存占用（特别是英文文本）
- 保持了相同的API，对开发者透明
