深入了解Java中的StringBuilder與StringBuffer
1. StringBuffer和StringBuilder的區(qū)別
因為字符串不可變，當(dāng)字符串拼接（尤其是使用+號操作符）時，需要考量性能的問題，不多毫無顧忌的創(chuàng)建太多String對象,從而對內(nèi)存造成不必要壓力。
因此Java專門設(shè)計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);
}
//...方法
}從上面代碼我們可以發(fā)現(xiàn)StringBuffer在進(jìn)行字符串操作時，方法都添加上synchronized關(guān)鍵字進(jìn)行同步，這主要是考慮到多線程環(huán)境下安全問題。因為加了synchronized,所以在非多線程下，執(zhí)行效率就會比較低，這是添加了沒必要的鎖。
考慮到性能問題，Java又給StringBuffer添加了一個孿生兄弟StringBuilder在方法上沒有添加synchronized關(guān)鍵字，因此無論單線程還是多線程效率都會高。
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關(guān)鍵字，所以StringBuilder多線程情況不安全 ，如果要在多線程環(huán)境下修改字符串，你到時候可以使用 ThreadLocal 來避免多線程沖突。
public class ThreadSafeStringBuilder {
// 使用ThreadLocal為每個線程提供獨立的StringBuilder對象
private static final ThreadLocal<StringBuilder> threadLocalStringBuilder = ThreadLocal.withInitial(StringBuilder::new);
public static void appendString(String str) {
// 獲取當(dāng)前線程的StringBuilder對象
StringBuilder stringBuilder = threadLocalStringBuilder.get();
// 在StringBuilder對象上執(zhí)行字符串拼接操作
stringBuilder.append(str);
}
public static String getString() {
// 獲取當(dāng)前線程的StringBuilder對象
StringBuilder stringBuilder = threadLocalStringBuilder.get();
// 返回StringBuilder對象的字符串表示
return stringBuilder.toString();
}
public static void main(String[] args) {
// 創(chuàng)建多個線程并發(fā)執(zhí)行字符串拼接操作
Runnable task = () -> {
for (int i = 0; i < 10; i++) {
appendString(Thread.currentThread().getName() + "-" + i + " ");
}
// 輸出當(dāng)前線程的字符串結(jié)果
System.out.println(Thread.currentThread().getName() + ": " + getString());
// 清空當(dāng)前線程的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();
}
// 等待所有線程執(zhí)行完成
for (Thread thread : threads) {
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}注意:實際開發(fā)中，StringBuilder 的使用頻率也是遠(yuǎn)高于 StringBuffer，甚至可以說，StringBuilder 完全取代了 StringBuffer。
2. StringBuilder使用
在深入解析 String.intern() 說過編譯器遇到 + 號這個操作符的時候，會將 new String("spring") + new String("葵花寶典") 編譯代碼如下:
new StringBuilder().append("spring").append("葵花寶典").toString();雖然過程我們看不見，這正是 Java 的只能之處，Java可以在編譯的時幫我們做很多優(yōu)化，這樣既可以提高我們的開發(fā)效率（+ 號寫起來比創(chuàng)建 StringBuilder 對象便捷得多），也不會影響 JVM 的執(zhí)行效率。
如果我們使用 javap 反編譯 new String("spring") + new String("葵花寶典") 的字節(jié)碼的時候，也是能看出 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可以發(fā)現(xiàn)Java 編譯器將字符串拼接操作（+）轉(zhuǎn)換為了 StringBuilder 對象的 append 方法，然后再調(diào)用 StringBuilder 對象的 toString 方法返回拼接后的字符串。
3. StringBuilder的內(nèi)部實現(xiàn)
3.1. StringBuilder的toString()方法
public String toString() {
return new String(value, 0, count);
}value 是一個 char 類型的數(shù)組
/**
* The value is used for character storage.
*/
char[] value;StringBuilder創(chuàng)建對象是，會給value分配內(nèi)存空間(初始容量16)，來存儲字符串。
public StringBuilder() {
super(16);
}隨著字符串不斷拼接,value數(shù)組長度會自動進(jìn)行擴(kuò)容操作，將字符數(shù)組長度增加到足夠容納新字符串的大小。value動態(tài)擴(kuò)容的過程類似于ArrayList中的擴(kuò)容機(jī)制，確保了在拼接大量字符串時的高效性
3.2. StringBuilder的append(String str) 方法
public StringBuilder append(String str) {
super.append(str);
return this;
}StringBuilder類的append(String str) 方法實際調(diào)用AbstractStringBuilder類中append方法。該方法會檢查當(dāng)前字符序列中的字符是否夠用，如果不夠用則會進(jìn)行擴(kuò)容，并將指定字符串追加到字符序列的末尾。
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) 方法將指定的字符串追加到當(dāng)前字符序列中。如果指定字符串為 null，則追加字符串 "null"；否則，該方法會檢查指定字符串的長度,根據(jù)當(dāng)前字符序列中已有字符的數(shù)量以及指定字符串的長度來判斷是否需要擴(kuò)容。如果需要擴(kuò)容，則會分配一個新的字符數(shù)組，將原有字符序列的內(nèi)容復(fù)制到新的字符數(shù)組中，并將指定字符串的內(nèi)容追加到新字符數(shù)組的末尾。這樣就確保了在追加字符串時，字符序列的容量始終能夠滿足當(dāng)前字符數(shù)量的需求，避免了不必要的內(nèi)存浪費說明:擴(kuò)容調(diào)用方法ensureCapacityInternal(int minimumCapacity)方法，擴(kuò)容之后，將指定字符串的字符拷貝到字符序列中。
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) 方法用于確保當(dāng)前字符序列的容量至少等于指定的最小容量 minimumCapacity。如果當(dāng)前容量小于指定的容量，就會為字符序列分配一個新的內(nèi)部數(shù)組。新容量的計算方式如下：
- 如果指定的最小容量大于當(dāng)前容量，則新容量為兩倍的舊容量加上 2。為什么要加 2 呢？這是因為在某些情況下，僅僅將容量加倍可能仍然不足以容納更多的字符。例如，對于非常小的字符串（比如空的或只有一個字符的 StringBuilder），僅僅將容量加倍可能仍然不足以容納更多的字符。因此，加上 2 提供了一個最小的增長量，確保即使對于很小的初始容量，擴(kuò)容后也能至少添加一些字符而不需要立即再次擴(kuò)容。
- 如果指定的最小容量小于等于當(dāng)前容量，則不會進(jìn)行擴(kuò)容，直接返回當(dāng)前對象。這樣做是為了避免不必要的內(nèi)存浪費和性能開銷。
3.4 StringBuilder的 reverse 方法
public StringBuilder reverse() {
super.reverse();
return this;
}StringBuilder類的reverse() 方法實際調(diào)用AbstractStringBuilder類中reverse()方法。該方法會檢查當(dāng)前字符序列中的字符是否夠用，如果不夠用則會進(jìn)行擴(kuò)容，并將指定字符串追加到字符序列的末尾。
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]; // 獲取當(dāng)前位置的字符
val[j] = val[k]; // 交換字符
val[k] = cj; // 交換字符
}
} else {
StringUTF16.reverse(val, count);
}
return this; // 返回反轉(zhuǎn)后的字符串構(gòu)建器對象
}1.初始化：
n表示字符串中最后一個字符索引
2.字符串反轉(zhuǎn)：
- 方法通過一個 for 循環(huán)遍歷字符串的前半部分和后半部分，這是一個非常巧妙的點，比從頭到尾遍歷省了一半的時間。(n-1) >> 1 是 (n-1) / 2 的位運(yùn)算表示，也就是字符串的前半部分的最后一個字符的索引。
- 在每次迭代中，計算出與當(dāng)前索引 j 對稱的索引 k，并交換這兩個索引位置的字符。
