Java 核心：char、String、StringBuilder 与 StringBuffer 深度解析

整数编码值：直接赋值为 Unicode 码点。

char c3 = 65;      // 十进制，对应 'A'
char c4 = 0101;    // 八进制，对应 'A'
char c5 = 0x41;    // 十六进制，对应 'A'

字符字面量：单引号括起来的单个字符。

char c1 = 'A';
char c2 = '中';

4. 运算规则

由于 char 底层存的是整数值，它可以进行算术运算，但要注意类型提升。

char ch = 'A';
System.out.println("ch is " + ch); // 输出：ch is A

// 将 'A' 的码点 (65) 加 1，得到 66，再强转为 char
ch = (char)(ch + 1);
System.out.println("ch is now " + ch); // 输出：ch is now B

// char 与 char 运算结果提升为 int
int sum = 'a' + 'b'; // 97 + 98 = 195
System.out.println(sum); // 输出：195

注意：char 参与运算时会自动提升为 int。若需赋值回 char 变量，必须显式强制转换 (char)。

二、不可变的字符串：String 类

String 是 Java 中使用频率最高的类之一，其不可变性是核心特征。

1. 类的定义与不可变性

查看 String 源码（以 JDK 8 为例，JDK 9 后底层变为 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;
    // ... 其他代码
}

• 类被 final 修饰：防止继承破坏不可变行为。
• 存储数组被 private final 修饰：引用不可变，且无法从外部访问。String 类未提供任何修改数组元素的方法，确保内部数据'不可变'。

2. 不可变性的优势

这种设计带来了显著好处：

• 线程安全：内容不可变，可在多线程间自由共享，无需同步。
• 哈希值缓存：hash 字段允许首次计算后缓存，使 String 极适合作为 HashMap 的键。

字符串常量池（String Pool）：这是不可变性带来的最大优化。创建字面量（如 String s = "hello";）时，JVM 检查池中是否存在相同内容。存在则复用引用，不存在则创建。这极大节省了内存。

String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); // 输出 true，指向常量池同一对象

3. 创建对象的两种方式

• 字面量赋值：String str1 = "abc"; 可能从常量池获取对象。
• new 关键字：String str2 = new String("abc"); 一定在堆中创建新对象。若池中无该字符串，会先在池中创建，再在堆中创建，通常涉及 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，堆中不同对象

4. 操作的真相：总是生成新对象

对 String 的任何修改操作（拼接、替换、截取）都返回新对象，原对象不变。

String original = "Hello";
String modified = original.concat(" World");
System.out.println(original); // Hello
System.out.println(modified); // Hello World

5. 拼接陷阱与优化

循环中使用 + 拼接会导致严重性能问题。

// 低效写法
String result = "";
for(int i = 0; i < 1000; i++) {
    result = result + i; // 每次循环新建 String 对象
}

JDK 5 后编译器会将 + 优化为 StringBuilder.append()。但在循环内，优化仍会导致每次循环新建 StringBuilder。因此，频繁修改字符串时，应手动使用 StringBuilder 或 StringBuffer。

三、可变的字符序列：StringBuilder 与 StringBuffer

为解决 String 不可变带来的性能问题，Java 提供了两个可变类。它们继承自 AbstractStringBuilder，底层使用可变数组（JDK 9 后为 byte[]）。

1. AbstractStringBuilder：共同祖先

虽然不能直接使用，但它是理解两者的关键。

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; // 扩容策略
        if(newCapacity < minimumCapacity) {
            newCapacity = minimumCapacity;
        }
        value = Arrays.copyOf(value, newCapacity);
    }
}

• 可变性：value 数组未被 final 修饰，可重新赋值或修改元素。
• 自动扩容：容量不足时触发 expandCapacity，通常按 2 倍 +2 增长。

2. StringBuilder：非线程安全的'快枪手'

• 引入时间：JDK 1.5。
• 特点：非线程安全。方法未使用 synchronized。
• 场景：单线程环境。无锁竞争，性能最佳，是默认选择。

3. StringBuffer：线程安全的'老大哥'

• 引入时间：JDK 1.0。
• 特点：线程安全。方法多用 synchronized 修饰。
• 场景：多线程环境。多个线程操作同一对象时保证数据正确。

@Override
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

4. 核心 API 对比

两者均实现 CharSequence，API 兼容，可无缝替换。

5. 性能对比

通过测试直观感受差异：

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 = 0; i < TIMES; i++) {
            sb.append("java");
        }
        String str = sb.toString();
        long end = System.currentTimeMillis();
        System.out.println("StringBuffer 拼接耗时：" + (end - start) + "ms");
    }

    public static void testStringBuilder() {
        long start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < TIMES; i++) {
            sb.append("java");
        }
        String str = sb.toString();
        long end = System.currentTimeMillis();
        System.out.println("StringBuilder 拼接耗时：" + (end - start) + "ms");
    }
}

典型结果（机器配置不同会有波动，但趋势一致）：

String 拼接耗时：1500ms
StringBuffer 拼接耗时：3ms
StringBuilder 拼接耗时：1ms

结论：

1. String 大量拼接性能最差，差几个数量级。
2. StringBuilder 比 StringBuffer 快，因省去了同步开销。

四、横向对比与选型指南

为了便于决策，这里将四个核心概念进行对比：

选型建议

1. 单个字符：用 char。
2. 少量、不变字符串：用 String。如配置项、常量。
3. 单线程大量操作：首选 StringBuilder。如构建 SQL、JSON、日志组装。
4. 多线程共享缓冲区：用 StringBuffer。如全局日志追加。
5. 作为 HashMap 键：必须用 String，依赖其不可变性和正确的 hashCode()。

五、常见面试题剖析

1. 谈谈你对 String 的理解，它为什么是不可变的？

答：体现在两点：

1. 类被 final 修饰，不可继承。
2. 底层存储数组被 private final 修饰，引用不可变，且类未提供修改数组元素的方法。所有看似修改的操作（如 concat, substring）都返回新对象。 这种设计带来了线程安全、常量池复用、哈希缓存等优势。

2. String、StringBuilder、StringBuffer 的区别？

答：

• 可变性：String 不可变；后两者可变。
• 线程安全：String 安全；StringBuffer 安全（synchronized）；StringBuilder 不安全。
• 性能：单线程下 StringBuilder 最快；StringBuffer 次之；String 修改时最差。

3. String s = new String("xyz"); 创建了几个对象？

答：取决于常量池是否有 "xyz"。

• 已有：堆中创建 1 个对象。
• 无：池中创建 1 个，堆中创建 1 个，共 2 个。

4. 为什么用 StringBuilder 要好于用 String 的'+'拼接？

答：编译器虽优化 + 为 StringBuilder，但在循环内，优化仍是局部的。每次循环都会生成新的 StringBuilder 对象，产生大量中间对象，增加 GC 压力。手动使用 StringBuilder 可在循环外创建一次，全程复用，效率更高。

总结

本文从微观的 char 讲起，深入剖析了 String 的不可变性及其设计权衡，并引出 StringBuilder 和 StringBuffer。通过对底层实现（可变数组与扩容机制）和线程安全性（synchronized 有无）的对比，明确了各自的优缺点。理解这些区别，不仅是应对面试，更是为了在日常开发中做出正确的技术选型，写出既高效又稳健的代码。