Java 字符串核心機制深度解析：String、StringBuffer、StringBuilder 與常量池全景圖

引言：為什麼字符串值得「特殊關照」？

字符串是程序開發中使用頻率最高、操作最複雜的數據類型之一。從 C/C++ 的字符數組操作到 Java/.NET 的專門優化，字符串的重要性不言而喻。日志系統每天產生的海量字符串對象，若不加特別設計，極易引發內存壓力與性能瓶頸。本文將系統梳理 Java 中 String 的不可變機制、常量池原理、比較陷阱，以及 StringBuffer/StringBuilder 的可變設計與性能優勢。

一、String：不可變的「最終形態」

1. 底層結構：final char 數組

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];  // JDK 8 及之前版本
    // private final byte[] value; // JDK 9+ 引入 Compact Strings
    // ...
}

final 修飾意味著：一旦創建，字符數組引用不可變，內容不可變。任何「修改」操作（拼接、替換、截取）實際上都是創建新 String 對象。

2. 字符串常量池：JVM 的去重優化

• 字面量賦值：String s = "abc"; → 編譯期確定，運行時進入常量池，相同內容共享同一對象。
• new 創建：String s1 = new String("abc"); → 堆中強制創建新對象，value 指向常量池中的 "abc"。

String s = "abc";
String s1 = "abc";
System.out.println(s == s1); // true，同一常量池對象

String s3 = new String("abc");
System.out.println(s == s3); // false，堆對象 vs 常量池對象
System.out.println(s.equals(s3)); // true，equals 比較值內容

3. equals 核心邏輯：先比引用，再比長度，最後逐字符比對

public boolean equals(Object anObject) {
    if (this == anObject) return true; // 引用相同直接 true
    if (anObject instanceof String) {
        String anotherString = (String) anObject;
        int n = value.length;
        if (n == anotherString.value.length) { // 長度不同直接 false
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) { // 逐字符比較
                if (v1[i] != v2[i]) return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

4. intern()：手動入池/獲取池中引用

String s = "abc";
String s3 = new String("abc");
System.out.println(s.intern() == s3.intern()); // true，均返回常量池中 "abc" 的引用

intern() 語義：若常量池已有內容相同字符串，返回池中引用；否則將此字符串放入池並返回引用。

二、StringBuffer vs StringBuilder：可變字符序列的雙子星

1. 核心區別：線程安全與性能

2. 底層共同祖先：AbstractStringBuilder

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    char[] value; // 非 final，可擴容
    int count;    // 當前字符數
    // ...
}

兩者均繼承 AbstractStringBuilder，核心操作委託給父類。

3. append 核心源碼解析：數組擴容 + System.arraycopy

public AbstractStringBuilder append(String str) {
    if (str == null) return appendNull();
    int len = str.length();
    ensureCapacityInternal(count + len); // 1. 確保容量，不足則擴容（通常 2倍+2）
    str.getChars(0, len, value, count);  // 2. 字符拷貝到 value 數組
    count += len;
    return this;
}

// String.getChars 內部調用
System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin); // 原生數組拷貝，極快

本質：在可變 char[] 上直接操作，避免了 String 每次操作創建新對象、新數組的開銷。

三、實戰性能對比：拼接 10 萬次

// String + 拼接：極慢，產生大量臨時對象，觸發頻繁 GC
String s = "";
for (int i = 0; i < 100000; i++) s += "a";

// StringBuilder：毫秒級完成，幾乎無 GC 壓力
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100000; i++) sb.append("a");
String result = sb.toString();

四、最佳實踐總結

1. 常量字符串拼接：編譯期優化，直接用 +，如 "a" + "b" + "c"。
2. 變量拼接/循環拼接：首選 StringBuilder（單線程），多線程用 StringBuffer。
3. 字符串比較：永遠用 equals()，除非確定比較的是同一常量池引用（如枚舉、常量）。
4. 需入池場景：大量重複業務字符串（如訂單狀態碼），調用 intern() 節省內存。
5. JDK 9+ Compact Strings：底層改為 byte[] + 編碼標識，ASCII 字符串內存佔用減半，無需代碼修改即享紅利。

結語

字符串看似簡單，實則蘊含 JVM 內存管理、性能優化的核心智慧。理解 final char[]、常量池、equals 語義、可變字符序列的數組擴容機制，是寫出高質量 Java 代碼、排查內存/性能問題的必修課。下次再寫 s1 + s2 時，腦海中浮現的應是：「這會不會產生不必要的對象？」