Java 中的 String、StringBuffer 与 StringBuilder：区别、联系与实战选型

String、StringBuffer、StringBuilder 是 Java 中处理字符串的核心类，三者都用于字符串操作，但在可变性、线程安全、性能上差异显著。本文从「核心特性→底层原理→性能对比→实战选型」全维度拆解，帮你精准掌握三者的使用场景。

一、核心特性对比（必记）

先通过表格快速掌握三者核心差异，这是选型的关键：

表格

二、底层原理深度解析

1. String：不可变的字符串

（1）不可变性的底层实现

String 被设计为不可变类（Immutable），核心原因：

• 类被final修饰，无法被继承；
• 存储字符的数组（JDK8：private final char value[]；JDK9+：private final byte[] value）被final + private修饰，引用不可变，且无对外修改的方法；
• 所有拼接、替换等操作都会新建 String 对象，原对象不会被修改。

（2）字符串拼接的性能问题

java

运行

// 看似简单的拼接，底层会频繁新建对象 String s = "a"; s += "b"; s += "c";

底层等价代码（编译后）：

java

运行

String s = "a"; s = new StringBuilder(s).append("b").toString(); s = new StringBuilder(s).append("c").toString();

每一次+=都会新建StringBuilder和String对象，频繁拼接时产生大量临时对象，触发 GC，性能极差。

（3）字符串常量池（String Pool）

String 的不可变性支撑了字符串常量池（JVM 堆中的一块区域），避免重复创建相同字符串：

• 字面量创建（String s = "abc"）：先检查常量池，有则复用，无则创建；
• new 创建（String s = new String("abc")）：先在常量池创建 "abc"，再在堆中创建新对象，慎用！

示例验证：

java

运行

String s1 = "abc"; String s2 = "abc"; String s3 = new String("abc"); System.out.println(s1 == s2); // true（常量池复用） System.out.println(s1 == s3); // false（堆中不同对象） System.out.println(s1.equals(s3)); // true（内容相等）

2. StringBuffer：线程安全的可变字符串

（1）线程安全的实现

StringBuffer 的所有修改方法（append()/insert()/replace()等）都被synchronized修饰，保证多线程下操作安全：

java

运行

// StringBuffer 核心方法源码（JDK8） @Override public synchronized StringBuffer append(String str) { toStringCache = null; super.append(str); return this; }

（2）扩容机制

StringBuffer 底层是可变字符数组，默认初始容量 16，当拼接的字符超过当前容量时，触发扩容：

• 新容量 = 原容量 × 2 + 2；
• 扩容时会复制原数组到新数组，产生性能开销（提前指定初始容量可优化）。

3. StringBuilder：高性能的可变字符串

（1）与 StringBuffer 的关系

StringBuilder 是 JDK5 引入的「非线程安全版 StringBuffer」，底层实现、扩容机制与 StringBuffer 完全一致，唯一区别是去掉了synchronized修饰，因此性能更高。

（2）性能优势的本质

无同步锁的开销，单线程下拼接操作的效率比 StringBuffer 高 10~20 倍（高频拼接场景差距更明显）。

三、核心用法示例

1. String 基础用法

java

运行

// 1. 字面量创建（推荐） String s1 = "Hello"; // 2. new 创建（不推荐，浪费内存） String s2 = new String("World"); // 3. 少量拼接（无性能问题） String s3 = s1 + " " + s2; // 4. 常用方法 System.out.println(s1.length()); // 5（长度） System.out.println(s1.charAt(0)); // H（获取字符） System.out.println(s1.equalsIgnoreCase("hello")); // true（忽略大小写比较） System.out.println(s1.substring(1, 3)); // el（子串） System.out.println(s1.replace("e", "E")); // HEllo（替换，返回新对象）

2. StringBuffer 用法（多线程场景）

java

运行

// 1. 指定初始容量（优化扩容） StringBuffer sb = new StringBuffer(100); // 2. 拼接操作（线程安全） sb.append("Java"); sb.append(" ").append("StringBuffer"); sb.insert(4, "SE "); // 在索引4插入 // 3. 转 String String result = sb.toString(); System.out.println(result); // JavaSE StringBuffer

3. StringBuilder 用法（单线程场景）

java

运行

// 1. 高频拼接（性能最优） StringBuilder sb = new StringBuilder(); for (int i = 0; i < 1000; i++) { sb.append(i); // 无临时对象，性能远高于 String += } String result = sb.toString(); System.out.println(result); // 0123...999

四、性能对比测试

通过代码验证三者在高频拼接场景下的性能差异：

java

运行

public class StringPerformanceTest { public static void main(String[] args) { int times = 100000; // 拼接次数 // 1. String 拼接（性能最差） long start1 = System.currentTimeMillis(); String s = ""; for (int i = 0; i < times; i++) { s += i; } long end1 = System.currentTimeMillis(); System.out.println("String 耗时：" + (end1 - start1) + "ms"); // 2. StringBuffer 拼接（性能中等） long start2 = System.currentTimeMillis(); StringBuffer sb1 = new StringBuffer(); for (int i = 0; i < times; i++) { sb1.append(i); } long end2 = System.currentTimeMillis(); System.out.println("StringBuffer 耗时：" + (end2 - start2) + "ms"); // 3. StringBuilder 拼接（性能最优） long start3 = System.currentTimeMillis(); StringBuilder sb2 = new StringBuilder(); for (int i = 0; i < times; i++) { sb2.append(i); } long end3 = System.currentTimeMillis(); System.out.println("StringBuilder 耗时：" + (end3 - start3) + "ms"); } }

测试结果（参考）

plaintext

String 耗时：8920ms StringBuffer 耗时：5ms StringBuilder 耗时：2ms

结论：高频拼接场景下，String 性能极差，StringBuilder 比 StringBuffer 快约 2 倍。

五、实战选型指南（核心）

1. 选 String 的场景

• 字符串内容不修改（如常量定义、参数传递、返回值）；
• 少量拼接（如 2~3 次+操作）；
• 需利用字符串常量池复用（字面量创建）。

2. 选 StringBuffer 的场景

• 多线程环境下需要频繁修改字符串（如多线程日志拼接、多线程数据拼接）；
• 要求线程安全，可接受同步锁的性能开销。

3. 选 StringBuilder 的场景

• 单线程环境下频繁修改字符串（如循环拼接、动态生成 SQL、JSON 字符串）；
• 追求极致性能，无线程安全要求（90% 的业务场景首选）。

4. 通用优化技巧

• 可变字符串（StringBuffer/StringBuilder）尽量指定初始容量（避免频繁扩容）；
• 避免在循环中使用String +=，优先用 StringBuilder；
• 字符串比较优先用equals()，而非==（==比较引用，equals比较内容）；
• JDK9+ 中，String 底层改为 byte 数组，存储单字节字符（如 ASCII）时更节省内存。

六、常见面试题

1. String 为什么是不可变的？类被 final 修饰，存储字符的数组被 final + private 修饰，无修改数组的方法，所有操作都新建对象。
2. String、StringBuffer、StringBuilder 的核心区别？String 不可变、线程安全、性能差；StringBuffer 可变、线程安全（synchronized）、性能中等；StringBuilder 可变、非线程安全、性能最优。
3. 为什么 StringBuilder 比 String 快？String 拼接新建对象，StringBuilder 直接修改底层数组，无临时对象和 GC 开销。
4. StringBuffer 的扩容机制？默认初始容量 16，扩容为原容量 ×2+2，扩容时复制数组。
5. String s = new String ("abc") 创建了几个对象？常量池无 "abc" 时创建 2 个（常量池 1 个，堆 1 个）；常量池已有 "abc" 时创建 1 个（堆中对象）。

总结

1. 核心差异：String 不可变、性能差；StringBuffer 可变、线程安全、性能中等；StringBuilder 可变、非线程安全、性能最优；
2. 选型原则：无修改选 String，单线程高频修改选 StringBuilder，多线程修改选 StringBuffer；
3. 性能优化：可变字符串指定初始容量，避免循环中 String += 操作。