本文详细解析了 Java 中处理字符和字符串的核心组件：char、String、StringBuilder 和 StringBuffer。文章首先介绍了 char 原始类型及其编码特性，重点阐述了 String 类的不可变性原理、内存优化及常量池机制。接着对比了 StringBuilder 和 StringBuffer 的可变性、线程安全性及底层实现差异，并通过性能测试展示了它们在字符串拼接场景下的表现。最后提供了选型指南和常见面试题解答，帮助开发者根据具体场景选择合适的工具，编写高效稳定的代码。
在 Java 编程中，char、String、StringBuilder 和 StringBuffer 是处理字符和字符串的四个基石。理解它们的设计哲学、底层实现和性能差异，对于编写高效、健壮的代码至关重要。
在探讨复杂的字符串类之前，我们首先需要了解构成字符串的最基本单元：char。
char 是 Java 中的一种原始数据类型（Primitive Type），用于表示一个单一的 16 位 Unicode 字符。在 Java 诞生之初，设计者就采用了 Unicode 字符集，这使得 Java 天生具有良好的国际化支持。
0 到 65,535（\u0000 到 \uffff）。char 是一个无符号类型，这意味着它不能表示负数。在 JDK 9 之前，String 类的内部实现也是采用 char[] 数组来存储字符。然而，一个深刻的洞察是，大多数应用程序使用的字符串主要由 Latin-1 字符集（如英文、数字）构成，这些字符仅需一个字节（8 位）即可表示，用两个字节的 char 来存储会造成一半的内存浪费。
因此，从 JDK 9 开始，为了优化内存占用，String（以及 StringBuilder 和 StringBuffer 的底层）不再使用 char[]，而是改用了 byte[] 数组，并引入一个 coder（编码器）字段来标识使用的是 LATIN1（每个字符 1 字节）还是 UTF16（每个字符 2 字节）编码。这是一个非常重要的底层变化，但对开发者来说是透明的，我们在逻辑上依然可以将它们视为字符序列。
char 的赋值方式非常灵活，可以通过以下几种方式：
转义字符：表示一些特殊功能字符。
char c7 = '\n'; // 换行符
char c8 = '\''; // 单引号字符本身
char c9 = '\\'; // 反斜杠字符本身
Unicode 转义序列：使用 \u 前缀加上 4 位十六进制数。
char c6 = '\u0041'; // 对应 'A'
整数编码值：直接赋值为字符在 Unicode 表中的码点（整数）。
char c3 = 65; // 十进制，对应 'A'
char c4 = 0101; // 八进制，对应 'A'
char c5 = 0x41; // 十六进制，对应 'A'
字符字面量：用单引号括起来的单个字符。可以是英文字母，也可以是中文字符。
char c1 = 'A';
char c2 = '中';
由于 char 底层存储的是整数值，因此它可以进行算术运算和比较。
char ch = 'A';
System.out.println("ch is " + ch); // 输出：ch is A
ch = (char) (ch + 1); // 将 'A' 的码点 (65) 加 1，得到 66，再强转为 char
System.out.println("ch is now " + ch); // 输出：ch is now B
char ch2 = 'a' + 'b'; // 'a'(97) + 'b'(98) = 195，结果在 int 范围内
System.out.println(ch2); // 输出：195 对应的字符？这里实际上输出的是 195 作为 char 类型的字符，需要查码表。
int sum = 'a' + 'b';
System.out.println(sum); // 输出：195
关键点：当 char 和 char 或 char 和 int 进行运算时，结果会被提升为 int 类型。如果需要重新赋给 char 变量，必须进行显式的强制类型转换 (char)。
String 类是 Java 中使用频率最高的类之一，其'不可变性'是其最核心的特征。
查看 String 类的源码（以 JDK 8 为例，后续版本底层数组变为 byte[]，但逻辑一致），我们可以清晰地看到其不可变性的实现：
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[]; // JDK 9 之后变为 private final byte[] value
/** Cache the hash code for the string */
private int hash; // Default to 0
// ... 其他代码
}
final 修饰：这意味着 String 类不能被继承，防止子类破坏其不可变行为。private final 修饰：value 数组的引用不可变，且无法从外部访问。final 保证了数组的引用一旦指向某个地址后就不能再改变。虽然没有直接的语法阻止数组内部元素的变化，但 String 类没有提供任何可以修改数组元素的方法，从而确保了内部的字符数组也'不可变'。这种精心的设计带来了许多好处：
String 类中有一个 hash 字段。因为字符串不可变，其哈希值在第一次计算后就可以被缓存起来，之后直接返回。这使得 String 非常适合作为 HashMap 或 HashTable 的键，提高了查找效率。字符串常量池（String Pool）：这是不可变性带来的最大性能优化之一。当创建一个字符串字面量（如 String s = "hello";）时，JVM 会检查常量池中是否已存在相同内容的字符串。如果存在，则直接返回其引用；如果不存在，则在池中创建新字符串并返回引用。这种机制极大地节省了内存。
String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); // 输出 true，因为指向常量池中的同一个对象
String str1 = "abc";方式二：new 关键字
String str2 = new String("abc");
这种方式一定会在堆（Heap）中创建一个新的 String 对象。如果常量池中还没有 "abc" 这个字符串，JVM 会先在常量池中创建，然后再在堆中创建对象。因此，这种方式通常会创建 1 个或 2 个对象。
String s3 = new String("hello");
String s4 = new String("hello");
System.out.println(s1 == s3); // 输出 false，s1 指向常量池，s3 指向堆
System.out.println(s3 == s4); // 输出 false，s3 和 s4 指向堆中不同的对象
理解了不可变性，就不难明白，对 String 对象的任何修改操作（如拼接、替换、截取），都不是在原对象上进行的，而是返回一个新的 String 对象。
String original = "Hello";
String modified = original.concat(" World");
System.out.println(original); // 输出：Hello (原对象未变)
System.out.println(modified); // 输出：Hello World (新对象)
String upper = original.toUpperCase();
System.out.println(original); // 输出：Hello
System.out.println(upper); // 输出：HELLO
正是由于上述特性，在循环中使用 + 进行字符串拼接会带来严重的性能问题。
// 低效的写法
String result = "";
for (int i = 0; i < 1000; i++) {
result = result + i; // 每次循环都会创建新的 String 对象
}
在 JDK 5 之后，Java 编译器会对 + 运算符进行优化，自动将其转换为 StringBuilder 的 append 操作。例如 String c = a + b; 会被编译为 (new StringBuilder()).append(a).append(b).toString();。但是，在循环体内，这种优化依然会导致每次循环都新建一个 StringBuilder 对象，反编译后的字节码可以清晰地证明这一点。因此，在循环或频繁修改字符串的场景下，我们必须手动使用 StringBuilder 或 StringBuffer。
为了解决 String 不可变带来的性能问题，Java 提供了两个可变的字符序列类：StringBuilder 和 StringBuffer。它们都继承自 AbstractStringBuilder 类，底层使用可变的字符数组（JDK 9 后为 byte[]）来存储数据。
虽然我们不能直接使用 AbstractStringBuilder，但它是理解这两个类的关键。
// 以 JDK 8 为例
abstract class AbstractStringBuilder implements Appendable, CharSequence {
char[] value; // 非 final，存储字符序列，JDK 9 后变为 byte[]
int count; // 已使用的字符个数
// 扩容机制
public void ensureCapacity(int minimumCapacity) {
if (minimumCapacity > value.length) {
expandCapacity(minimumCapacity);
}
}
void expandCapacity(int minimumCapacity) {
int newCapacity = value.length * 2 + 2; // 新容量通常是旧容量的 2 倍 +2
if (newCapacity < minimumCapacity) { newCapacity = minimumCapacity; }
// 创建新数组并复制原数据 value = Arrays.copyOf(value, newCapacity);
// ...}
// ...}
value 数组没有被 final 修饰，可以被重新赋值指向一个新的数组地址，也可以修改数组内部元素。append 或 insert 方法时，如果当前字符序列的长度超过了底层数组的容量，它会自动触发 expandCapacity 方法，创建一个更大的新数组（通常是原容量的 2 倍 +2），并将原内容复制过去。append, insert, delete 等）都没有使用 synchronized 关键字进行同步。StringBuffer 对象时。在这种场景下，为了保证数据的正确性，必须使用 StringBuffer。核心特点：线程安全。它的绝大多数方法都使用了 synchronized 关键字修饰，确保在多线程并发访问时，不会出现数据错乱的问题。
// StringBuffer 的 append 方法
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}
三个类都实现了 CharSequence 接口，因此它们的方法非常相似。StringBuilder 和 StringBuffer 的 API 是兼容的，可以无缝替换。
| 方法分类 | 常用方法 | 描述 |
|---|---|---|
| 构造器 | StringBuilder() / StringBuffer() | 创建一个初始容量为 16 字符的空对象。 |
StringBuilder(int capacity) | 指定初始容量。 | |
StringBuilder(String str) | 根据字符串创建，初始容量为 16 + str.length()。 | |
| 追加 | append(任意类型 x) | 将参数的字符串表示形式追加到序列末尾。这是最常用的方法，支持重载。 |
| 插入 | insert(int offset, 任意类型 x) | 在指定位置插入参数的字符串表示形式。 |
| 删除 | delete(int start, int end) | 删除从 start 到 end-1 的子序列。 |
deleteCharAt(int index) | 删除指定位置的字符。 | |
| 替换与反转 | replace(int start, int end, String str) | 用 str 替换指定范围的字符。 |
reverse() | 将序列反转。 | |
| 修改 | setCharAt(int index, char ch) | 修改指定位置的字符。 |
| 查询 | charAt(int index) / length() | 获取指定字符/长度。 |
indexOf(String str) / lastIndexOf(String str) | 查找子串位置。 | |
| 转 String | toString() | 返回此序列中数据的字符串表示形式。 |
下面通过一个简单的性能测试来直观感受三者的差异：
public class PerformanceTest {
private static final int TIMES = 20000;
public static void main(String[] args) {
testString();
testStringBuffer();
testStringBuilder();
}
public static void testString() {
long start = System.currentTimeMillis();
String str = "";
for (int i = 0; i < TIMES; i++) {
str += "java";
}
long end = System.currentTimeMillis();
System.out.println("String 拼接耗时：" + (end - start) + "ms");
}
public static void testStringBuffer() {
long start = System.currentTimeMillis();
StringBuffer sb = new StringBuffer();
for (int ; i < TIMES; i++) {
sb.append();
}
sb.toString();
System.currentTimeMillis();
System.out.println( + (end - start) + );
}
{
System.currentTimeMillis();
();
( ; i < TIMES; i++) {
sb.append();
}
sb.toString();
System.currentTimeMillis();
System.out.println( + (end - start) + );
}
}
典型输出结果（不同机器配置有差异，但趋势一致）：
String 拼接耗时：1500ms
StringBuffer 拼接耗时：3ms
StringBuilder 拼接耗时：1ms
结论：
String 的 + 操作在大量拼接时性能最差，差了几个数量级。StringBuilder 通常比 StringBuffer 快（本例中快 2-3 倍），因为省去了同步开销。为了让你一目了然，这里将四个核心概念进行横向对比：
| 特性 | char | String | StringBuilder | StringBuffer |
|---|---|---|---|---|
| 类型 | 原始数据类型 | 类 | 类 | 类 |
| 不可变性 | / | 不可变 (Immutable) | 可变 (Mutable) | 可变 (Mutable) |
| 线程安全 | / | 线程安全 (通过不可变性) | 非线程安全 | 线程安全 (通过 synchronized) |
| 底层存储 | 16 位 Unicode 值 | byte[] (JDK 9+) | byte[] (JDK 9+) | byte[] (JDK 9+) |
| 性能（修改操作） | N/A | 极差（创建大量对象） | 最高 | 中等（有同步开销） |
| 适用场景 | 存储单个字符 | 操作少的字符串、常量、作为键的 HashMap | 单线程下大量字符串操作（如循环拼接） | 多线程下共享的字符串缓冲区 |
char。String。例如配置项、常量、不经常变化的文本。StringBuilder。例如，在方法内部构建复杂的 SQL 语句、处理 JSON 字符串、日志组装等。这是最常见的场景。StringBuffer 来保证数据同步和安全。例如，一个全局的日志缓冲区，多个线程都要向其追加内容。String，因为其不可变性和正确的 hashCode() 实现。答：String 的不可变性体现在：
final 修饰，不可继承，防止子类破坏。byte[] (或 char[]) 数组被 private final 修饰，引用不可变，且 String 类没有提供任何可以修改该数组内部元素的方法（如 setCharAt()）。所有看似修改的操作，如 concat(), substring(), replace() 等，都是返回一个新的 String 对象。答：三者都是用来处理字符串的，主要区别如下：
String 是不可变类，操作后产生新对象。StringBuilder 和 StringBuffer 是可变类，可以在原对象上修改。String 是线程安全的。StringBuffer 的方法使用了 synchronized 修饰，是线程安全的。StringBuilder 的方法没有同步，是线程不安全的。StringBuilder 的性能最好，因为它没有同步开销。StringBuffer 次之。String 在进行大量修改时性能最差。答：这取决于'xyz'这个字符串常量是否已经存在于字符串常量池中。
String 对象。答案是 1 个。String 对象。答案是 2 个。答：虽然编译器会将 + 优化为 StringBuilder，但在循环等场景中，优化是局部的。例如 for 循环内的 +，每次循环都会在循环体内生成一个新的 StringBuilder 对象，然后调用 append()，最后调用 toString() 返回。这会产生大量的中间对象，给垃圾回收带来巨大压力，严重影响性能。而手动使用 StringBuilder 可以在循环外部创建一个对象，在整个循环中复用这一个对象进行 append，极大地减少了对象创建，提升了效率。
本文从微观的 char 原始类型讲起，深入剖析了其在 Java 中的 Unicode 特性和运算规则。随后，我们详细探讨了 String 类的不可变性及其带来的设计权衡，并由此引出为了解决性能问题而诞生的 StringBuilder 和 StringBuffer。通过对它们底层实现（继承自 AbstractStringBuilder 的可变数组与扩容机制）和线程安全性（synchronized 关键字的有无）的对比，我们明确了各自的优缺点和适用场景。
理解这些核心概念的区别与联系，不仅仅是应对面试，更是为了在日常开发中做出正确的技术选型，写出既高效又稳健的代码。希望这篇详解能帮助你彻底掌握 Java 中字符与字符串的奥秘。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 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