1. 为什么Java需要三种字符串类？
在Java开发中，我们经常需要处理字符串操作。但你是否想过，为什么Java要提供String、StringBuffer和StringBuilder三种字符串处理类？这要从字符串在Java中的特殊地位说起。
字符串在Java中具有不可变性（immutable）的特性。这意味着一旦创建了一个String对象，它的值就不能被改变。这种设计带来了几个关键优势：
- 线程安全性：不可变对象天生线程安全
- 缓存哈希值：String的hashCode可以缓存，提高集合操作效率
- 字符串常量池：实现字符串共享，节省内存
然而，这种不可变性也带来了性能问题。当我们频繁修改字符串时，每次操作都会创建新的String对象，导致内存和性能开销。这就是StringBuffer和StringBuilder出现的原因。
提示：在JDK 1.5之前，字符串拼接操作（+）实际上是通过StringBuffer实现的，但每次拼接都会新建StringBuffer对象，效率仍然不高。JDK 1.5之后改为了StringBuilder实现。
2. String类的深度解析
2.1 String的底层实现
String类的核心是一个final的char数组：
java复制public final class String {
private final char value[];
// 其他字段和方法...
}
这个设计决定了String的关键特性：
- final类：不能被继承，保证了字符串操作的安全性
- final char数组：内容不可变
- 实现了Serializable、Comparable和CharSequence接口
2.2 字符串创建方式对比
Java中有两种创建字符串的方式：
java复制String str1 = "hello"; // 字面量方式
String str2 = new String("hello"); // 构造器方式
它们的区别在于：
- 字面量方式会检查字符串常量池，如果存在则直接引用，否则创建新对象并放入池中
- new方式强制在堆中创建新对象，不检查常量池
2.3 String的常用方法陷阱
String提供了丰富的方法，但有些行为需要注意：
- substring():
java复制String str = "hello world";
String sub = str.substring(0, 5); // 创建新对象
- concat():
java复制String s1 = "hello";
String s2 = s1.concat(" world"); // 创建新对象
- replace():
java复制String s = "hello";
s = s.replace('h', 'H'); // 创建新对象
所有这些方法都不会修改原字符串，而是返回新对象。这在循环中使用时会导致大量临时对象产生。
3. StringBuffer与StringBuilder详解
3.1 可变字符串的实现原理
StringBuffer和StringBuilder都继承自AbstractStringBuilder，核心是一个可变的char数组：
java复制abstract class AbstractStringBuilder {
char[] value; // 非final
int count; // 实际字符数
// 方法实现...
}
这种设计允许它们在原有缓冲区上进行修改，避免了频繁创建新对象。
3.2 关键方法解析
- append()方法：
java复制public StringBuilder append(String str) {
super.append(str);
return this; // 返回this实现链式调用
}
- 扩容机制：
当需要添加的内容超过当前容量时，会进行扩容：
java复制void expandCapacity(int minimumCapacity) {
int newCapacity = value.length * 2 + 2;
if (newCapacity < minimumCapacity)
newCapacity = minimumCapacity;
value = Arrays.copyOf(value, newCapacity);
}
默认初始容量为16，扩容策略是原容量×2+2。
3.3 StringBuffer的线程安全实现
StringBuffer通过synchronized关键字实现线程安全：
java复制public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}
每个方法都加了同步锁，保证了多线程环境下的安全性，但也带来了性能开销。
4. 三者的性能对比与使用场景
4.1 性能测试实验
我们通过一个简单的拼接测试来比较三者的性能：
java复制public class PerformanceTest {
private static final int COUNT = 100000;
public static void main(String[] args) {
testString();
testStringBuffer();
testStringBuilder();
}
static void testString() {
long start = System.currentTimeMillis();
String s = "";
for (int i = 0; i < COUNT; i++) {
s += "a";
}
System.out.println("String: " + (System.currentTimeMillis() - start) + "ms");
}
static void testStringBuffer() {
long start = System.currentTimeMillis();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < COUNT; i++) {
sb.append("a");
}
System.out.println("StringBuffer: " + (System.currentTimeMillis() - start) + "ms");
}
static void testStringBuilder() {
long start = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < COUNT; i++) {
sb.append("a");
}
System.out.println("StringBuilder: " + (System.currentTimeMillis() - start) + "ms");
}
}
典型测试结果（JDK 8）：
code复制String: 4321ms
StringBuffer: 8ms
StringBuilder: 5ms
4.2 使用场景建议
根据测试结果和特性分析，我们得出以下使用建议：
- String适用场景：
- 字符串不经常修改
- 需要字符串常量池特性
- 作为HashMap的key使用
- StringBuilder适用场景：
- 单线程环境下频繁修改字符串
- 性能要求高的场景
- 方法内部的局部变量
- StringBuffer适用场景：
- 多线程环境下修改字符串
- 全局变量或会被多个线程访问的变量
注意：在JDK 5+中，简单的字符串拼接（如"a"+"b"）会被编译器自动优化为StringBuilder实现，但循环中的拼接仍需要注意。
5. 常见面试问题深度解析
5.1 字符串相等性比较
java复制String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = s3.intern();
System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // false
System.out.println(s1 == s4); // true
解释：
- s1和s2指向常量池中的同一个对象
- s3是堆中新创建的对象
- intern()方法会返回常量池中的引用
5.2 final关键字的影响
java复制final String a = "hello";
String b = a + " world"; // 编译时优化为"hello world"
String c = "hello world";
System.out.println(b == c); // true
String d = getHello() + " world"; // 运行时确定
System.out.println(d == c); // false
final变量在编译时会被替换为实际值，使得字符串拼接可以在编译期优化。
5.3 字符串拼接的性能陷阱
以下两种写法性能差异很大：
java复制// 方式一：高效
String result = "a" + "b" + "c"; // 编译期优化为"abc"
// 方式二：低效
String a = "a";
String b = "b";
String c = "c";
String result = a + b + c; // 运行时创建StringBuilder
6. 高级技巧与最佳实践
6.1 初始化容量优化
对于已知最终大小的字符串操作，初始化时指定容量可以避免多次扩容：
java复制// 预计最终长度约为1000
StringBuilder sb = new StringBuilder(1000);
for (int i = 0; i < 100; i++) {
sb.append("0123456789");
}
6.2 字符串拼接的替代方案
对于超大量字符串拼接，可以考虑：
- 使用StringJoiner（JDK 8+）
java复制StringJoiner sj = new StringJoiner(",");
sj.add("a").add("b").add("c");
String result = sj.toString();
- 使用String的join方法（JDK 8+）
java复制String result = String.join(",", "a", "b", "c");
6.3 内存优化技巧
- 重用StringBuilder：
java复制StringBuilder sb = new StringBuilder();
for (Item item : items) {
sb.setLength(0); // 清空内容重用
sb.append(item.getName()).append(": ").append(item.getValue());
process(sb.toString());
}
- 避免在循环中创建格式化字符串：
java复制// 不好
for (int i = 0; i < 100; i++) {
String s = String.format("Value: %d", i);
}
// 更好
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
sb.setLength(0);
sb.append("Value: ").append(i);
String s = sb.toString();
}
7. 实际项目中的经验总结
在多年Java开发中，我总结了以下关于字符串处理的实战经验：
- 日志拼接优化：
日志输出经常需要拼接多个变量，使用StringBuilder可以显著提升性能：
java复制// 不推荐
log.debug("User " + userId + " accessed " + resource);
// 推荐
if (log.isDebugEnabled()) {
StringBuilder sb = new StringBuilder(64);
sb.append("User ").append(userId).append(" accessed ").append(resource);
log.debug(sb.toString());
}
- SQL拼接注意事项：
虽然不推荐字符串拼接SQL，但在某些场景下不可避免时：
java复制StringBuilder sql = new StringBuilder(128);
sql.append("SELECT * FROM users WHERE 1=1");
if (name != null) {
sql.append(" AND name = '").append(escapeSql(name)).append("'");
}
// 必须注意SQL注入问题
- 性能关键路径优化：
在高频调用的方法中，我通常会：
- 将StringBuilder声明为局部变量而非类成员
- 根据经验值预设足够大的初始容量
- 避免在循环内创建临时String对象
-
多线程环境下的选择：
即使是在多线程环境中，如果字符串操作是方法内的局部变量，仍然可以使用StringBuilder而非StringBuffer，因为局部变量不会被多个线程共享。 -
内存泄漏防范：
超大StringBuilder在使用后应及时置空，特别是在长时间存活的对象中：
java复制class Processor {
private StringBuilder buffer = new StringBuilder(1024 * 1024);
void process() {
try {
// 使用buffer处理数据
} finally {
buffer.setLength(0); // 清空内容释放内存
}
}
}