在Java开发中，字符串操作是最基础也是最频繁使用的功能之一。Java提供了三种主要的字符串处理类：String、StringBuffer和StringBuilder。本文将深入剖析这三者的区别，从底层实现到实际应用场景，帮助开发者做出合理选择。
一、不可变的String类：安全但效率受限
1.1 String的核心特性
String类代表不可变的字符序列，这是其最本质的特征。所谓不可变，指的是String对象一旦创建，其包含的字符内容就不能再被修改。这种不可变性是通过final关键字实现的：
public final class String implements Serializable, Comparable<String>, CharSequence {
private final char value[]; // 使用final修饰的字符数组存储数据
// 其他成员变量和方法...
}1.2 不可变性的实际表现
当我们对String对象进行"修改"操作时，实际上创建了新的String对象：
String str = "初始内容";
str = str + "追加内容"; // 这里不是修改原对象，而是创建了新对象这个过程中，JVM首先会创建包含"初始内容"的String对象，然后在拼接操作时，又会创建包含"追加内容"的新对象，最后生成包含完整内容的全新String对象。原来的两个字符串对象实际上仍然存在于内存中，只是不再被引用。
1.3 String的创建方式
String对象有两种创建方式，它们在内存分配上有重要区别：
- 字面量方式：
String str = "Hello";
-
- 这种方式创建的字符串会被放入字符串常量池
- 如果常量池已存在相同内容，则直接引用现有对象
- new关键字方式：
String str = new String("Hello");
-
- 这种方式会在堆内存中创建新的String对象
- 即使内容相同，也会创建新的对象实例
1.4 String的适用场景
由于不可变特性，String最适合以下场景：
- 字符串内容不需要频繁修改
- 作为HashMap的键（因为不可变性保证了hashCode的一致性）
- 需要保证线程安全的场景（不可变对象天生线程安全）
- 字符串常量或在编译期可以确定的内容
二、可变的StringBuffer：线程安全的字符串构建者
2.1 StringBuffer的核心特点
StringBuffer代表可变的字符序列，它与String最大的区别就是内容可变。StringBuffer内部维护一个字符数组，当进行修改操作时，直接在原对象上进行，不会创建新对象。
StringBuffer sb = new StringBuffer("初始内容");
sb.append("追加内容"); // 直接修改原对象2.2 线程安全实现机制
StringBuffer的线程安全性是通过方法级别的同步实现的：
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}可以看到，所有修改方法都使用synchronized关键字修饰，确保多线程环境下的安全访问。
2.3 容量管理策略
StringBuffer内部采用动态扩容机制，初始默认容量为16个字符。当内容超出当前容量时，会自动扩容：新容量 = (原容量 + 1) * 2。这种策略减少了内存重新分配的次数，提高了性能。
// StringBuffer的扩容代码片段
void expandCapacity(int minimumCapacity) {
int newCapacity = value.length * 2 + 2;
if (newCapacity - minimumCapacity < 0)
newCapacity = minimumCapacity;
if (newCapacity < 0) {
if (minimumCapacity < 0) // overflow
throw new OutOfMemoryError();
newCapacity = Integer.MAX_VALUE;
}
value = Arrays.copyOf(value, newCapacity);
}2.4 StringBuffer的适用场景
StringBuffer特别适合以下情况：
- 多线程环境下需要频繁修改字符串内容
- 需要保证线程安全的字符串拼接操作
- 不确定最终字符串长度的动态构建场景
三、高效的StringBuilder：单线程环境的最佳选择
3.1 StringBuilder的核心特点
StringBuilder与StringBuffer在功能上几乎完全相同，都是可变的字符序列。关键区别在于StringBuilder没有实现线程安全，因此性能更高。
StringBuilder sb = new StringBuilder("初始内容");
sb.append("追加内容"); // 非同步的高效操作3.2 与StringBuffer的性能对比
由于省去了同步开销，StringBuilder在单线程环境下性能明显优于StringBuffer。通过以下测试可以直观看到差异：
final int COUNT = 100000;
// StringBuilder测试
long start = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < COUNT; i++) {
sb.append(i);
}
System.out.println("StringBuilder耗时：" + (System.currentTimeMillis() - start) + "ms");
// StringBuffer测试
start = System.currentTimeMillis();
StringBuffer sbf = new StringBuffer();
for (int i = 0; i < COUNT; i++) {
sbf.append(i);
}
System.out.println("StringBuffer耗时：" + (System.currentTimeMillis() - start) + "ms");测试结果通常显示StringBuilder比StringBuffer快20%-30%。
3.3 实现细节分析
StringBuilder与StringBuffer都继承自AbstractStringBuilder，共享大部分实现代码。关键区别在于方法是否同步：
// StringBuilder的append方法（非同步）
public StringBuilder append(String str) {
super.append(str);
return this;
}
// StringBuffer的append方法（同步）
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}3.4 StringBuilder的适用场景
StringBuilder是以下场景的首选：
- 单线程环境下需要频繁修改字符串
- 性能要求较高的字符串处理
- 明确的单线程使用环境
- 局部变量的字符串拼接
四、三者的性能对比与内存分析
4.1 性能对比测试
我们通过一个更全面的测试来比较三种类的性能差异：
public class StringPerformanceTest {
private static final int LOOP_COUNT = 50000;
public static void main(String[] args) {
// String测试
long stringStart = System.nanoTime();
String stringResult = "";
for (int i = 0; i < LOOP_COUNT; i++) {
stringResult += i;
}
long stringTime = System.nanoTime() - stringStart;
// StringBuffer测试
long bufferStart = System.nanoTime();
StringBuffer bufferResult = new StringBuffer();
for (int i = 0; i < LOOP_COUNT; i++) {
bufferResult.append(i);
}
long bufferTime = System.nanoTime() - bufferStart;
// StringBuilder测试
long builderStart = System.nanoTime();
StringBuilder builderResult = new StringBuilder();
for (int i = 0; i < LOOP_COUNT; i++) {
builderResult.append(i);
}
long builderTime = System.nanoTime() - builderStart;
System.out.println("String拼接耗时：" + stringTime / 1000000 + "ms");
System.out.println("StringBuffer拼接耗时：" + bufferTime / 1000000 + "ms");
System.out.println("StringBuilder拼接耗时：" + builderTime / 1000000 + "ms");
}
}4.2 内存使用分析
三种类在内存使用上有显著差异：
- String：
-
- 每次拼接都创建新对象
- 产生大量中间垃圾对象
- 内存占用随操作次数线性增长
- StringBuffer/StringBuilder：
-
- 始终使用同一个对象
- 只在需要时扩容内部数组
- 内存使用更高效
4.3 JVM层面的优化
现代JVM会对String拼接进行一些优化，例如将多个连续的+操作转换为StringBuilder操作：
// 源代码
String result = str1 + str2 + str3;
// 编译器优化后
String result = new StringBuilder().append(str1).append(str2).append(str3).toString();但这种优化有局限性，在循环中仍然会产生大量StringBuilder对象。
五、实际开发中的选择建议
5.1 选择标准
在实际项目中，应根据以下因素选择合适的字符串类：
- 线程安全要求：
-
- 需要线程安全：StringBuffer
- 不需要线程安全：StringBuilder
- 字符串修改频率：
-
- 频繁修改：StringBuffer/StringBuilder
- 很少修改：String
- 性能要求：
-
- 高性能需求：StringBuilder
- 可以接受一定性能损失：StringBuffer
- 代码可读性：
-
- 简单拼接：String的
+操作更直观 - 复杂构建：StringBuilder更清晰
- 简单拼接：String的
5.2 最佳实践
- 简单的字符串拼接：
// 少量拼接使用String即可
String message = "用户" + userName + "于" + time + "登录";- 循环内的字符串构建：
// 使用StringBuilder
StringBuilder sqlBuilder = new StringBuilder("SELECT * FROM users WHERE ");
for (String condition : conditions) {
sqlBuilder.append(condition).append(" AND ");
}
// 移除末尾多余的" AND "
sqlBuilder.setLength(sqlBuilder.length() - 5);
String sql = sqlBuilder.toString();- 多线程环境下的日志构建：
// 使用StringBuffer保证线程安全
public class Logger {
private StringBuffer logBuffer = new StringBuffer();
public synchronized void log(String message) {
logBuffer.append(new Date()).append(": ").append(message).append("\n");
}
public String getLog() {
return logBuffer.toString();
}
}六、JDK1.8中的实现细节
6.1 底层存储结构
三者在JDK1.8中都使用char数组存储字符：
// AbstractStringBuilder中的定义
char[] value; // 存储字符的数组
int count; // 已使用的字符数6.2 字符串拼接的实现差异
String的+操作实际上是通过StringBuilder实现的：
// 源代码
String s = "a" + "b" + "c";
// 编译器处理后
String s = new StringBuilder().append("a").append("b").append("c").toString();6.3 字符串常量池的影响
String对象会利用字符串常量池，而StringBuffer/StringBuilder不会：
String s1 = "hello"; // 使用常量池
String s2 = "hello"; // 重用常量池中的对象
String s3 = new String("hello"); // 创建新对象
System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // false七、常见误区与注意事项
7.1 误区一：总是使用String
很多初学者习惯性使用String进行所有字符串操作，这在频繁修改的场景会导致性能问题。
不良实践：
String result = "";
for (int i = 0; i < 10000; i++) {
result += i; // 每次循环都创建新String对象
}改进方案：
StringBuilder builder = new StringBuilder();
for (int i = 0; i < 10000; i++) {
builder.append(i); // 只需一个对象
}
String result = builder.toString();7.2 误区二：在多线程中使用StringBuilder
虽然StringBuilder在单线程中性能更好，但在多线程环境中可能导致数据不一致。
错误示例：
// 多线程环境下不安全的用法
public class UnsafeStringBuilderExample {
private static StringBuilder sharedBuilder = new StringBuilder();
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < 100; i++) {
executor.execute(() -> {
sharedBuilder.append(Thread.currentThread().getName());
});
}
executor.shutdown();
// 结果可能丢失部分数据或出现混乱
}
}正确做法：
// 使用StringBuffer或外部同步
private static StringBuffer sharedBuffer = new StringBuffer();
// 或者
private static final Object lock = new Object();
private static StringBuilder sharedBuilder = new StringBuilder();
// 使用时同步
synchronized(lock) {
sharedBuilder.append(content);
}7.3 注意事项：初始容量设置
对于已知大致长度的字符串构建，设置合理的初始容量可以避免多次扩容：
// 预估最终长度约10000字符
StringBuilder builder = new StringBuilder(10000);
for (int i = 0; i < items.size(); i++) {
builder.append(items.get(i));
}八、扩展知识：Java 9后的变化
虽然本文基于JDK1.8，但值得了解Java 9后的重要变化：
- 内部存储从char数组改为byte数组，配合编码标志位，更节省内存
- String拼接的实现优化
- 新增了一些字符串处理方法
九、总结
String、StringBuffer和StringBuilder各有其设计目的和适用场景：
- String：
-
- 不可变，线程安全
- 适合字符串常量和不频繁修改的场景
- 性能最差但使用最简单
- StringBuffer：
-
- 可变，线程安全
- 适合多线程环境下的字符串构建
- 性能中等，有同步开销
- StringBuilder：
-
- 可变，非线程安全
- 适合单线程环境下的字符串构建
- 性能最佳
在实际开发中，应根据具体需求选择合适的字符串类。记住以下原则：
- 优先考虑线程安全需求
- 在单线程中总是首选StringBuilder
- 避免在循环中使用String进行拼接
- 对于已知长度的构建，设置合理的初始容量
通过合理选择字符串处理类，可以显著提高Java应用程序的性能和内存使用效率。
扫一扫
1528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
