Java 核心：char、String、StringBuilder 与 StringBuffer 详解

字符字面量：

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

1.4 运算规则

char 底层存的是整数值，可以参与算术运算。注意类型提升问题。

char ch = 'A';
System.out.println("ch is " + ch); // 输出：ch is A
ch = (char) (ch + 1);              // 强制转换，'A'(65)+1=66 -> 'B'
System.out.println("ch is now " + ch);

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

注意：char 与 char 或 int 运算时，结果自动提升为 int。若需赋回 char，必须显式强转 (char)。

2. 不可变的字符串——String 类

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

2.1 类的定义与不可变性

查看 JDK 源码（以 JDK 8 为例，JDK 9 后底层变 byte[] 但逻辑一致）：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    private final char value[]; // JDK 9 后变为 private final byte[] value
    private int hash;
}

• 类被 final 修饰：防止继承破坏不可变性。
• 数组被 private final 修饰：引用不可变，且类不提供修改数组元素的方法。

2.2 不可变性的优势

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

• 线程安全：内容不可变，多线程共享无需同步。
• 哈希缓存：hash 字段可缓存计算结果，适合作为 HashMap 键。
• 字符串常量池：字面量创建时检查池中是否已存在，复用对象节省内存。

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

2.3 创建对象的两种方式

1. 字面量：String str1 = "abc"; 可能从常量池获取。
2. new 关键字：String str2 = new String("abc"); 一定在堆中创建新对象。

String s3 = new String("hello");
String s4 = new String("hello");
System.out.println(s3 == s4); // false，堆中不同对象

2.4 操作真相：总是生成新对象

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

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

2.5 拼接陷阱与优化

循环中使用 + 拼接会导致大量临时对象产生。

// 低效写法
String result = "";
for (int i = 0; i < 1000; i++) {
    result = result + i;
}

虽然编译器会将 + 优化为 StringBuilder.append()，但在循环体内每次迭代仍会新建 StringBuilder。因此，频繁修改场景应手动使用 StringBuilder。

3. 可变的字符序列——StringBuilder 与 StringBuffer

为了解决 String 性能问题，Java 提供了两个可变类，均继承自 AbstractStringBuilder。

3.1 AbstractStringBuilder：共同祖先

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    char[] value; // JDK 9 后变为 byte[]，非 final
    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 数组可重新赋值或修改内容。
• 扩容机制：超出容量时自动扩容（通常是旧容量的 2 倍 +2）。

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

• 引入时间：JDK 1.5。
• 特点：非线程安全，方法无 synchronized。
• 场景：单线程下首选，性能最好。

3.3 StringBuffer：线程安全的'老大哥'

• 引入时间：JDK 1.0。
• 特点：线程安全，方法多用 synchronized 修饰。
• 场景：多线程共享缓冲区时使用。

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

3.4 核心 API 对比

两者 API 兼容，常用方法如下：

3.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";
        }
        System.out.println("String 耗时：" + (System.currentTimeMillis() - start) + "ms");
    }
    
    public static void testStringBuffer() {
        long start = System.currentTimeMillis();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < TIMES; i++) {
            sb.append("java");
        }
        System.out.println("StringBuffer 耗时：" + (System.currentTimeMillis() - start) + "ms");
    }
    
    public static void testStringBuilder() {
        long start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < TIMES; i++) {
            sb.append("java");
        }
        System.out.println("StringBuilder 耗时：" + (System.currentTimeMillis() - start) + "ms");
    }
}

典型结果：String 最慢，StringBuilder 最快，StringBuffer 居中（受锁影响）。

4. 横向对比与选型指南

4.1 怎么选？

1. 单个字符：用 char。
2. 少量/不变字符串：用 String（如配置项、Map 键）。
3. 单线程大量操作：首选 StringBuilder（如 SQL 拼接、日志组装）。
4. 多线程共享：必须用 StringBuffer。

5. 常见面试题剖析

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

答：String 不可变体现在类被 final 修饰，底层数组 private final 且无修改方法。所有修改操作返回新对象。这带来了线程安全、常量池复用、哈希缓存等优势。

2. String、StringBuilder、StringBuffer 的区别？

答：

• 可变性：String 不可变，另两者可变。
• 线程安全：String 和 StringBuffer 安全，StringBuilder 不安全。
• 性能：单线程下 StringBuilder 最快，String 频繁修改最差。

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

答：取决于常量池。

• 若池中有 "xyz"：堆中 1 个对象。
• 若池中无 "xyz"：池中 1 个 + 堆中 1 个，共 2 个。

4. 为什么 StringBuilder 优于 String 的'+'拼接？

答：编译器虽优化 + 为 StringBuilder，但在循环内每次迭代仍会新建对象。手动 StringBuilder 可在循环外创建一次并复用，大幅减少 GC 压力。

总结

从 char 的底层编码到 String 的不可变设计，再到 StringBuilder 与 StringBuffer 的性能权衡，理解这些区别不仅是面试需求，更是日常开发中做出正确技术选型的基础。掌握它们，能让你的代码既稳健又高效。