深入了解Java中的StringBuilder與StringBuffer
1. StringBuffer和StringBuilder的區別
因為字符串不可變，當字符串拼接（尤其是使用+號操作符）時，需要考量性能的問題，不多毫無顧忌的創建太多String對象,從而對內存造成不必要壓力。
因此Java專門設計StringBuilder類來解決該問題
public final class StringBuffer extends AbstractStringBuilder implements Serializable, CharSequence {
public StringBuffer() {
super(16);
}
public synchronized StringBuffer append(String str) {
super.append(str);
return this;
}
public synchronized String toString() {
return new String(value, 0, count);
}
//...方法
}從上面代碼我們可以發現StringBuffer在進行字符串操作時，方法都添加上synchronized關鍵字進行同步，這主要是考慮到多線程環境下安全問題。因為加了synchronized,所以在非多線程下，執行效率就會比較低，這是添加了沒必要的鎖。
考慮到性能問題，Java又給StringBuffer添加了一個孿生兄弟StringBuilder在方法上沒有添加synchronized關鍵字，因此無論單線程還是多線程效率都會高。
public final class StringBuilder extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{
// ...
public StringBuilder append(String str) {
super.append(str);
return this;
}
public String toString() {
// Create a copy, don't share the array
return new String(value, 0, count);
}
// ...其他方法
}但是因為方法上沒有synchronized關鍵字，所以StringBuilder多線程情況不安全 ，如果要在多線程環境下修改字符串，你到時候可以使用 ThreadLocal 來避免多線程沖突。
public class ThreadSafeStringBuilder {
// 使用ThreadLocal為每個線程提供獨立的StringBuilder對象
private static final ThreadLocal<StringBuilder> threadLocalStringBuilder = ThreadLocal.withInitial(StringBuilder::new);
public static void appendString(String str) {
// 獲取當前線程的StringBuilder對象
StringBuilder stringBuilder = threadLocalStringBuilder.get();
// 在StringBuilder對象上執行字符串拼接操作
stringBuilder.append(str);
}
public static String getString() {
// 獲取當前線程的StringBuilder對象
StringBuilder stringBuilder = threadLocalStringBuilder.get();
// 返回StringBuilder對象的字符串表示
return stringBuilder.toString();
}
public static void main(String[] args) {
// 創建多個線程并發執行字符串拼接操作
Runnable task = () -> {
for (int i = 0; i < 10; i++) {
appendString(Thread.currentThread().getName() + "-" + i + " ");
}
// 輸出當前線程的字符串結果
System.out.println(Thread.currentThread().getName() + ": " + getString());
// 清空當前線程的StringBuilder對象，以便下次使用
threadLocalStringBuilder.get().setLength(0);
};
// 啟動多個線程
Thread[] threads = new Thread[5];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(task);
threads[i].start();
}
// 等待所有線程執行完成
for (Thread thread : threads) {
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}注意:實際開發中，StringBuilder 的使用頻率也是遠高于 StringBuffer，甚至可以說，StringBuilder 完全取代了 StringBuffer。
2. StringBuilder使用
在深入解析 String.intern() 說過編譯器遇到 + 號這個操作符的時候，會將 new String("spring") + new String("葵花寶典") 編譯代碼如下:
new StringBuilder().append("spring").append("葵花寶典").toString();雖然過程我們看不見，這正是 Java 的只能之處，Java可以在編譯的時幫我們做很多優化，這樣既可以提高我們的開發效率（+ 號寫起來比創建 StringBuilder 對象便捷得多），也不會影響 JVM 的執行效率。
如果我們使用 javap 反編譯 new String("spring") + new String("葵花寶典") 的字節碼的時候，也是能看出 StringBuilder 的影子。
0: new #2 // class java/lang/StringBuilder
3: dup
4: invokespecial #3 // Method java/lang/StringBuilder."<init>":()V
7: new #4 // class java/lang/String
10: dup
11: ldc #5 // String spring
13: invokespecial #6 // Method java/lang/String."<init>":(Ljava/lang/String;)V
16: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
19: new #4 // class java/lang/String
22: dup
23: ldc #8 // String 葵花寶典
25: invokespecial #6 // Method java/lang/String."<init>":(Ljava/lang/String;)V
28: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
31: invokevirtual #9 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
34: astore_1
35: return可以發現Java 編譯器將字符串拼接操作（+）轉換為了 StringBuilder 對象的 append 方法，然后再調用 StringBuilder 對象的 toString 方法返回拼接后的字符串。
3. StringBuilder的內部實現
3.1. StringBuilder的toString()方法
public String toString() {
return new String(value, 0, count);
}value 是一個 char 類型的數組
/**
* The value is used for character storage.
*/
char[] value;StringBuilder創建對象是，會給value分配內存空間(初始容量16)，來存儲字符串。
public StringBuilder() {
super(16);
}隨著字符串不斷拼接,value數組長度會自動進行擴容操作，將字符數組長度增加到足夠容納新字符串的大小。value動態擴容的過程類似于ArrayList中的擴容機制，確保了在拼接大量字符串時的高效性
3.2. StringBuilder的append(String str) 方法
public StringBuilder append(String str) {
super.append(str);
return this;
}StringBuilder類的append(String str) 方法實際調用AbstractStringBuilder類中append方法。該方法會檢查當前字符序列中的字符是否夠用，如果不夠用則會進行擴容，并將指定字符串追加到字符序列的末尾。
public AbstractStringBuilder append(String str) {
if (str == null) {
return appendNull();
}
int len = str.length();
ensureCapacityInternal(count + len);
putStringAt(count, str);
count += len;
return this;
}AbstractStringBuilder類的append(String str) 方法將指定的字符串追加到當前字符序列中。如果指定字符串為 null，則追加字符串 "null"；否則，該方法會檢查指定字符串的長度,根據當前字符序列中已有字符的數量以及指定字符串的長度來判斷是否需要擴容。如果需要擴容，則會分配一個新的字符數組，將原有字符序列的內容復制到新的字符數組中，并將指定字符串的內容追加到新字符數組的末尾。這樣就確保了在追加字符串時，字符序列的容量始終能夠滿足當前字符數量的需求，避免了不必要的內存浪費說明:擴容調用方法ensureCapacityInternal(int minimumCapacity)方法，擴容之后，將指定字符串的字符拷貝到字符序列中。
3.3. AbstractStringBuilder的ensureCapacityInternal(int minimumCapacity)方法
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
int oldCapacity = value.length >> coder;
if (minimumCapacity - oldCapacity > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity) << coder);
}
}
private int newCapacity(int minCapacity) {
// overflow-conscious code
int oldCapacity = value.length >> coder;
int newCapacity = (oldCapacity << 1) + 2;
if (newCapacity - minCapacity < 0) {
newCapacity = minCapacity;
}
int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
return (newCapacity <= 0 || SAFE_BOUND - newCapacity < 0)
? hugeCapacity(minCapacity)
: newCapacity;
}ensureCapacityInternal(int minimumCapacity) 方法用于確保當前字符序列的容量至少等于指定的最小容量 minimumCapacity。如果當前容量小于指定的容量，就會為字符序列分配一個新的內部數組。新容量的計算方式如下：
- 如果指定的最小容量大于當前容量，則新容量為兩倍的舊容量加上 2。為什么要加 2 呢？這是因為在某些情況下，僅僅將容量加倍可能仍然不足以容納更多的字符。例如，對于非常小的字符串（比如空的或只有一個字符的 StringBuilder），僅僅將容量加倍可能仍然不足以容納更多的字符。因此，加上 2 提供了一個最小的增長量，確保即使對于很小的初始容量，擴容后也能至少添加一些字符而不需要立即再次擴容。
- 如果指定的最小容量小于等于當前容量，則不會進行擴容，直接返回當前對象。這樣做是為了避免不必要的內存浪費和性能開銷。
3.4 StringBuilder的 reverse 方法
public StringBuilder reverse() {
super.reverse();
return this;
}StringBuilder類的reverse() 方法實際調用AbstractStringBuilder類中reverse()方法。該方法會檢查當前字符序列中的字符是否夠用，如果不夠用則會進行擴容，并將指定字符串追加到字符序列的末尾。
public AbstractStringBuilder reverse() {
byte[] val = this.value;
int count = this.count;
int coder = this.coder;
int n = count - 1; // 字符序列的最后一個字符的索引
if (COMPACT_STRINGS && coder == LATIN1) {
for (int j = (n-1) >> 1; j >= 0; j--) {
int k = n - j; // 計算相對于 j 對稱的字符的索引
byte cj = val[j]; // 獲取當前位置的字符
val[j] = val[k]; // 交換字符
val[k] = cj; // 交換字符
}
} else {
StringUTF16.reverse(val, count);
}
return this; // 返回反轉后的字符串構建器對象
}1.初始化：
n表示字符串中最后一個字符索引
2.字符串反轉：
- 方法通過一個 for 循環遍歷字符串的前半部分和后半部分，這是一個非常巧妙的點，比從頭到尾遍歷省了一半的時間。(n-1) >> 1 是 (n-1) / 2 的位運算表示，也就是字符串的前半部分的最后一個字符的索引。
- 在每次迭代中，計算出與當前索引 j 對稱的索引 k，并交換這兩個索引位置的字符。
