Java 中 char、String、StringBuilder 与 StringBuffer 核心解析

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

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

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

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

1.4 char 的运算

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);

char ch2 = 'a' + 'b';              // 97 + 98 = 195
System.out.println(ch2);           // 输出 195 对应的字符
int sum = 'a' + 'b';
System.out.println(sum);           // 输出：195

注意：char 运算结果会提升为 int。如果要赋回 char，必须显式强转 (char)。

第二章：不可变的字符串——String 类

String 是 Java 最核心的类之一，'不可变性'是它的灵魂。

2.1 类的定义与不可变性

看源码（以 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.2 不可变性的优势

这种设计好处不少：

• 线程安全：内容不变，多线程共享无需同步。
• 哈希值缓存：hash 字段存了计算好的哈希值。因为对象不变，算一次就够了。这让 String 做 HashMap 键非常合适。

字符串常量池（String Pool）：这是最大的优化。创建字面量（如 String s = "hello";）时，JVM 检查池中是否有相同内容。有则复用引用，没有则新建。这极大省内存。

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

2.3 创建 String 对象的两种方式

• 字面量赋值：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，堆里不同对象

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

理解了不可变性，就知道任何修改操作（拼接、替换）都不是原地改，而是返回新对象。

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; // 每次循环都新建 String
}

JDK 5 后编译器会把 + 优化成 StringBuilder.append。但在循环里，每次迭代还是会新建一个 StringBuilder。反编译字节码能看清这一点。所以循环或频繁修改场景，必须手动用 StringBuilder 或 StringBuffer。

第三章：可变的字符序列——StringBuilder 与 StringBuffer

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

3.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，然后复制数据。

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 对比

三者都实现了 CharSequence，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";
        }
        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 快，因为省了同步开销。

第四章：横向对比与选型指南

为了方便记忆，这里做个横向对比：

4.1 选型指南：到底该用谁？

1. 单个字符：用 char。
2. 少量、不变字符串：用 String。比如配置项、常量。
3. 单线程、大量操作：首选 StringBuilder。SQL 组装、JSON 处理、日志拼接都是典型场景。
4. 多线程、共享缓冲区：必须 StringBuffer。比如全局日志缓冲，多线程同时写。
5. HashMap 键：必须 String。依赖不可变性和正确的 hashCode()。

第五章：常见面试题深度剖析

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

答：体现在两点：

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

2. String、StringBuilder、StringBuffer 的区别？

答：

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

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

答：看常量池有没有 "xyz"。

• 有：只在堆建 1 个对象。
• 无：池里建 1 个，堆里建 1 个，共 2 个。

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

答：编译器虽会优化 + 为 StringBuilder，但在循环里，每次迭代仍会新建一个 StringBuilder 对象。这会制造大量垃圾，增加 GC 压力。手动在外层创建一个 StringBuilder 并复用，效率更高。

总结

从 char 的 Unicode 特性讲起，我们深入探讨了 String 的不可变性及其带来的权衡，进而引出 StringBuilder 和 StringBuffer。通过对比底层实现（可变数组与扩容）和线程安全性（有无 synchronized），明确了各自的优缺点。掌握这些区别不仅是面试需求，更是日常开发中做出正确技术选型、写出高效代码的关键。