一. 可變字符串

1. 簡(jiǎn)介

在Java中，我們除了可以通過String類創(chuàng)建和處理字符串之外，還可以使用StringBuffer和StringBuilder類來(lái)處理字符串。其中，String類定義的字符串內(nèi)容不可變，所以String屬于不可變字符串。而StringBuffer和StringBuilder定義的字符串內(nèi)容可變，這兩者屬于可變字符串，并且StringBuffer和StringBuilder，對(duì)字符串的處理效率比String類更高。

2. 使用場(chǎng)景

有的小伙伴可能還是不太理解，字符串的使用并不是很難，咱們直接使用String來(lái)操作就可以了，為什么還要搞出來(lái)StringBuffer和StringBuilder這兩個(gè)類？這不是找麻煩嗎？其實(shí)這都是有原因的！

從底層原理來(lái)分析，String構(gòu)建的字符串對(duì)象，其內(nèi)容理論上是不能被改變的。一旦定義了String對(duì)象就無(wú)法再改變其內(nèi)容，但很多時(shí)候我們還是需要改變字符串的內(nèi)容的，所以String類就存在一定的短板。

另外從應(yīng)用層面來(lái)分析，String字符串的執(zhí)行效率其實(shí)是比較低的。舉個(gè)例子，就比如常見的字符串拼接，很多人喜歡使用“+號(hào)”來(lái)拼接String字符串。其實(shí)如果是操作少量的字符串，使用String還湊活，一旦同時(shí)操作的字符串過多，String的效率就極低了。之前曾做過一個(gè)關(guān)于10萬(wàn)個(gè)字符串拼接的實(shí)驗(yàn)。同等條件下，利用“+”號(hào)進(jìn)行拼接所需要的時(shí)間是29382毫秒，利用StringBuffer所需要的時(shí)間只有4毫秒，而StringBuilder所用的時(shí)間更是只需2毫秒，這效率真是天差地別！

另外我們還可以通過下面這個(gè)稍微簡(jiǎn)單點(diǎn)的案例，來(lái)看看Java底層是如何處理字符串拼接的。

String str = "Hello" + "World";
System.out.println("str=" + str);

相信很多朋友都會(huì)用 “+”號(hào) 來(lái)進(jìn)行字符串拼接，因?yàn)橛X得該方式簡(jiǎn)單方便，畢竟 一 “+” 了事。那么利用 “+”號(hào)來(lái)拼接字符串是最好的方案嗎？肯定不是的！如果我們使用JAD反編譯工具對(duì)上述Java字節(jié)碼進(jìn)行反編譯，你會(huì)發(fā)現(xiàn)不一樣的結(jié)果，上述案例反編譯后得到的JAD文件內(nèi)容如下所示：

import java.io.PrintStream;
public class StringTest13{
    public StringTest13(){
    }
    public static void main(String args[]){
        String s = "HelloWorld";
        System.out.println((new StringBuilder()).append("str=").append(s).toString());
    }
}

從反編譯出來(lái)的JAD文件中我們可以看出，Java在編譯的時(shí)候會(huì)把 “+”號(hào)操作符替換成StringBuilder的append()方法。也就是說(shuō)，“+”號(hào)操作符在拼接字符串的時(shí)候只是一種形式，讓開發(fā)者使用起來(lái)比較簡(jiǎn)便，代碼看起來(lái)比較簡(jiǎn)潔，但底層使用的還是StringBuilder操作。

既然 “+”號(hào) 的底層還是利用StringBuilder的append()方法操作，那么我們?yōu)槭裁床恢苯邮褂肧tringBuilder呢？你說(shuō)對(duì)吧？而且當(dāng)我們需要操作大量的字符串時(shí)，更不推薦使用String，比如：

String str = "";
for (int i = 0; i < 10000; i++) {
    str = str + "," + i;
}

上面這段代碼，雖然可以實(shí)現(xiàn)字符串的拼接，但是在該循環(huán)中，每次循環(huán)都會(huì)創(chuàng)建一個(gè)新的字符串對(duì)象，然后扔掉舊的字符串。如果是10000次循環(huán)，就會(huì)執(zhí)行10000次這樣的操作。而這些操作中的絕大部分字符串對(duì)象都是臨時(shí)對(duì)象，最終都會(huì)被扔掉不用，這就會(huì)嚴(yán)重地浪費(fèi)內(nèi)存，并會(huì)嚴(yán)重影響GC垃圾回收的效率。

為了能提高拼接字符串的效率，Java給我們提供了StringBuffer和StringBuilder，它們都是可變對(duì)象，可以預(yù)分配緩沖區(qū)。當(dāng)我們往StringBuffer或 StringBuilder 中新增字符時(shí)，不會(huì)創(chuàng)建新的臨時(shí)對(duì)象，可以極大地節(jié)省了內(nèi)存。 可以說(shuō)，好處多多。

那么接下來(lái)就帶領(lǐng)各位來(lái)學(xué)習(xí)StringBuffer、StringBuilder的用法吧。

二. StringBuffer

1. 簡(jiǎn)介

StringBuffer是一種可變的字符串類，即在創(chuàng)建StringBuffer對(duì)象后，我們還可以隨意修改字符串的內(nèi)容。每個(gè)StringBuffer的類對(duì)象都能夠存儲(chǔ)指定容量的字符串，如果字符串的長(zhǎng)度超過了StringBuffer對(duì)象的容量空間，則該對(duì)象的容量會(huì)自動(dòng)擴(kuò)大。

另外我們?cè)谑褂肧tringBuffer類時(shí)，比如每次調(diào)用toString()方法，都會(huì)直接使用緩存區(qū)的toStringCache 值來(lái)構(gòu)造一個(gè)字符串，這每次都是對(duì)StringBuffer對(duì)象本身進(jìn)行操作，而不會(huì)重新生成一個(gè)新對(duì)象。所以如果我們需要對(duì)大量字符串的內(nèi)容進(jìn)行修改，推薦大家使用StringBuffer。

2. 基本特性

StringBuffer作為一個(gè)可變字符串類，具有如下特性：

• 具有線程安全性：StringBuffer中的公開方法都由synchronized關(guān)鍵字修飾，保證了線程同步；
• 帶有緩沖區(qū)：StringBuffer每次調(diào)用toString()方法時(shí)，都會(huì)直接使用緩存區(qū)的toStringCache值來(lái)構(gòu)造一個(gè)字符串；
• 內(nèi)容可變性：StringBuffer中帶有字符串緩沖區(qū)，我們可以通過數(shù)組的復(fù)制來(lái)實(shí)現(xiàn)內(nèi)容的修改；
• 自帶擴(kuò)容機(jī)制：StringBuffer可以初始化容量，也可以指定容量，當(dāng)字符串長(zhǎng)度超過了指定的容量后，可以通過擴(kuò)容機(jī)制實(shí)現(xiàn)長(zhǎng)度的變更；
• 內(nèi)容類型多樣性：StringBuffer中可以存儲(chǔ)多種不同類型的數(shù)據(jù)。

了解了StringBuffer的基本特性之后，請(qǐng)大家跟著小編來(lái)學(xué)習(xí)一下StringBuffer的基本用法吧。

3. 基本用法

3.1 常用API方法

StringBuffer作為一個(gè)字符串操作類，它有以下幾個(gè)需要我們掌握的常用API方法，如下所示：

3.2 基本案例

知道了這些常用的API方法后，我們?cè)偻ㄟ^一個(gè)案例來(lái)看看這些方法到底是怎么用的。

/**
 * @author 
 */
public class Demo01 {
    public static void main(String[] args) {
	//創(chuàng)建StringBuffer對(duì)象
        StringBuffer sb = new StringBuffer("跟一一哥，");
        //在字符串后面追加新的字符串
        sb.append("學(xué)Java！");
        System.out.println(sb); 
        //刪除指定位置上的字符串，從指定的下標(biāo)開始和結(jié)束，下標(biāo)從0開始
        sb.delete(2, 4);
        System.out.println(sb);//"一哥"
        //在指定下標(biāo)位置上添加指定的字符串
        sb.insert(2, "123");
        System.out.println(sb);//跟一123，學(xué)Java！
        //將字符串翻轉(zhuǎn)
        sb.reverse();
        System.out.println(sb);//！avaJ學(xué)，321一跟
        //將StringBuffer轉(zhuǎn)換成String類型
        String s = sb.toString();
        System.out.println(s);
    }
}

3.3 append()用法

在以上幾個(gè)方法中，再重點(diǎn)給大家說(shuō)一下append()追加方法。該方法的作用是追加內(nèi)容到當(dāng)前StringBuffer對(duì)象的末尾，類似于字符串的連接。調(diào)用該方法以后，StringBuffer對(duì)象的內(nèi)容也會(huì)發(fā)生改變。使用該方法進(jìn)行字符串的連接，會(huì)比String更加節(jié)約內(nèi)存。我們可以利用append()方法進(jìn)行動(dòng)態(tài)內(nèi)容的追加，比如進(jìn)行數(shù)據(jù)庫(kù)SQL語(yǔ)句的拼接：

/**
 * @author 
 */
public class Demo02 {
    public static void main(String[] args) {
	StringBuffer sb = new StringBuffer();
	String user = "yyg";
	String pwd = "123";
		
	//實(shí)現(xiàn)SQL語(yǔ)句的拼接
	sb.append("select * from userInfo where username=")
          .append(user)
	  .append(" and pwd=")
	  .append(pwd);

	System.out.println("sql="+sb.toString());
    }
}

StringBuffer的用法其實(shí)很簡(jiǎn)單，和String差不多，大家簡(jiǎn)單掌握即可。

三. StringBuilder

1. 簡(jiǎn)介

要想實(shí)現(xiàn)可變字符串的操作，其實(shí)還有另一個(gè)StringBuilder類，該類是在Java 5中被提出的。它和 StringBuffer的基本用法幾乎是完全一樣的，關(guān)于StringBuilder的用法，不會(huì)講解太多。

但StringBuilder和StringBuffer最大的不同在于，StringBuilder的各個(gè)方法都不是線程安全的(不能同步訪問)，在多線程時(shí)可能存在線程安全問題，但StringBuilder的執(zhí)行效率卻比StringBuffer快的多。

實(shí)際上大多數(shù)情況下，我們都是在單線程下進(jìn)行字符串的操作，所以使用StringBuilder并不會(huì)產(chǎn)生線程安全問題。所以針對(duì)大多數(shù)的單線程情況，還是建議大家使用StringBuilder，而不是StringBuffer，除非你們的項(xiàng)目對(duì)線程安全有著明確的高要求。

2. 特性

StringBuilder作為可變字符串操作類，具有如下特性：

• StringBuilder是線程不安全的，但執(zhí)行效率更快；
• 適用于單線程環(huán)境下，在字符緩沖區(qū)進(jìn)行大量操作的情況。

3. 基本用法

StringBuilder的API方法和基本用法與StringBuffer一樣，此處略過。

四. 擴(kuò)容機(jī)制(重點(diǎn))

擴(kuò)容機(jī)制應(yīng)該是本篇文章中的一個(gè)重難點(diǎn)，所以要結(jié)合源碼，單獨(dú)列出一節(jié)給大家仔細(xì)分析一下。

在常規(guī)的用法上面，StringBuffer和StringBuilder基本沒有什么差別。兩者的主要區(qū)別在于StringBuffer是線程安全的，但效率低，StringBuilder是線程不安全的，但效率高。不過在擴(kuò)容機(jī)制上，StringBuffer和StringBuilder是一樣的。所以在這里，就以StringBuffer為例，只給大家分析一個(gè)類即可。

1. 繼承關(guān)系

首先我們可以追蹤一下StringBuffer的源碼，看看它繼承自哪個(gè)父類。

從上圖可以看出，StringBuffer和StringBuilder其實(shí)都是繼承自AbstractStringBuilder，所以StringBuffer與StringBuilder這兩者可以說(shuō)是“親兄弟”的關(guān)系，它們倆有一個(gè)共同的抽象父類AbstractStringBuilder，如下所示：

2. AbstractStringBuilder抽象父類

在之前給大家講解抽象類時(shí)就跟大家說(shuō)過，抽象類可以將多個(gè)子類個(gè)性化的實(shí)現(xiàn)，通過抽象方法交由子類來(lái)實(shí)現(xiàn)；而多個(gè)子類共性的方法，可以放在父類中實(shí)現(xiàn)。StringBuffer和StringBuilder的共同父類AbstractStringBuilder就是一個(gè)抽象類，在這個(gè)父類中把StringBuffer和StringBuilder的一些共同內(nèi)容進(jìn)行了定義。比如在該類中，就定義了一個(gè)定長(zhǎng)的字節(jié)數(shù)組來(lái)保存字符串，后面當(dāng)我們利用append()方法不斷地追加字符串時(shí)，如果該字符串的長(zhǎng)度超過了這個(gè)數(shù)組的長(zhǎng)度，就會(huì)利用數(shù)組復(fù)制的方式給該數(shù)組進(jìn)行擴(kuò)容。

3. 容量設(shè)置

另外在前面給大家講解StringBuffer的API方法時(shí)，也給大家說(shuō)過StringBuffer有3個(gè)構(gòu)造方法。而無(wú)論是哪個(gè)構(gòu)造方法都可以設(shè)置存儲(chǔ)容量，即使是默認(rèn)的構(gòu)造方法也會(huì)有值為16的存儲(chǔ)容量，如下圖所示：

4. 擴(kuò)容過程(核心)

4.1 StringBuffer#append()方法

雖然StringBuffer有默認(rèn)的容量設(shè)置，也有自定義的容量設(shè)置，但在實(shí)際開發(fā)過程中，容量還是有可能不夠用。這時(shí)就會(huì)根據(jù)追加的字符串長(zhǎng)度進(jìn)行動(dòng)態(tài)擴(kuò)容，那么這個(gè)擴(kuò)容過程到底是怎么樣的呢？其實(shí)StringBuffer的擴(kuò)容需要利用append()方法作為入口，我們先來(lái)看看append()方法的源碼，如下所示：

4.2 AbstractStringBuilder#append()方法

在StringBuffer的append()方法中，你會(huì)發(fā)現(xiàn)實(shí)際上真正的實(shí)現(xiàn)是通過super關(guān)鍵字，在調(diào)用父類的append()方法，所以我們繼續(xù)往下追蹤，此時(shí)進(jìn)入到AbstractStringBuilder類中的append()方法中，如下圖所示：

此時(shí)我們看到了一個(gè)ensureCapacityInternal()方法，從字面意思來(lái)理解，該方法是用于確保內(nèi)部容量。傳遞給該方法的個(gè)參數(shù)是count+len，也就是 原有字符串的長(zhǎng)度+新追加的字符串長(zhǎng)度，即append后字符串的總長(zhǎng)度。

4.3 ensureCapacityInternal()方法

那么ensureCapacityInternal()接受了新字符串的總長(zhǎng)度之后會(huì)發(fā)生什么變化呢？我們必須進(jìn)入到ensureCapacityInternal()方法的內(nèi)部來(lái)探究一番，源碼如下：

在該方法中，我們首先看到了一個(gè)二進(jìn)制位的右移運(yùn)算。value.length是字符數(shù)組的長(zhǎng)度，結(jié)合coder參數(shù)進(jìn)行右移運(yùn)算，得到字符串的原有容量。這里的coder參數(shù)是一種編碼方式，如果字符串中沒有中文，默認(rèn)是采用Latin1編碼，如果有中文則會(huì)采用UTF-16編碼。因?yàn)閁TF-16編碼中文時(shí)需要兩個(gè)字節(jié)，也就是說(shuō)，只要字符串中含有中文，value字節(jié)數(shù)組中是每?jī)晌粚?duì)應(yīng)一個(gè)字符。

然后會(huì)判斷新追加的字符串長(zhǎng)度是否超過了value字節(jié)數(shù)組的長(zhǎng)度，如果新字符串的長(zhǎng)度大于value字節(jié)數(shù)組的長(zhǎng)度，則說(shuō)明需要給該字節(jié)數(shù)組進(jìn)行擴(kuò)容。接著就會(huì)利用用Arrays.copyOf()方法，將當(dāng)前數(shù)組的值拷貝給newCapacity()個(gè)長(zhǎng)度的新數(shù)組，最后再重新賦值給value字節(jié)數(shù)組。在擴(kuò)容的過程中，主要是利用數(shù)組復(fù)制的方法來(lái)實(shí)現(xiàn)！

4.4 newCapacity()方法

其實(shí)講到現(xiàn)在，關(guān)于StringBuffer的擴(kuò)容，基本原理已經(jīng)給大家講清楚了，但我們還可以繼續(xù)深入看看newCapacity()這個(gè)方法的實(shí)現(xiàn)過程與返回值，它與數(shù)組擴(kuò)容密切相關(guān)。

該方法的大致作用就是，獲取value數(shù)組的原有長(zhǎng)度和待追加的新字符串長(zhǎng)度，利用ArraysSupport.newLength()方法計(jì)算出擴(kuò)容后新數(shù)組的長(zhǎng)度length，并最終返回該length。如果length的值等于Integer的最大值，說(shuō)明我們傳遞過來(lái)的字符串太長(zhǎng)了，就會(huì)直接觸發(fā)一個(gè)內(nèi)存溢出的異常。

4.5 newLength()方法

而ArraysSupport.newLength()方法的內(nèi)部實(shí)現(xiàn)，主要是利用Math.max()方法實(shí)現(xiàn)的，如下所示：

4.6 小結(jié)(重點(diǎn))

至此，就把StringBuffer的擴(kuò)容過程給大家分析完畢了，最后，再給大家把這個(gè)擴(kuò)容的核心思路總結(jié)一下，StringBuffer擴(kuò)容機(jī)制的基本規(guī)則如下：

• 如果一次追加的字符長(zhǎng)度超過了當(dāng)前設(shè)置的容量，則會(huì)按照 當(dāng)前容量*2+2 進(jìn)行擴(kuò)容；
• 如果一次追加的長(zhǎng)度不僅超過了初始容量，而且按照 當(dāng)前容量*2+2 擴(kuò)容一次還不夠， 其容量會(huì)直接擴(kuò)容到與所添加字符串長(zhǎng)度相等的長(zhǎng)度 ；
• 之后如果還要再追加新的字符內(nèi)容，依然會(huì)按照 當(dāng)前容量*2+2 進(jìn)行擴(kuò)容。

5. 驗(yàn)證案例

最后為了驗(yàn)證上述結(jié)論是否正確，再給大家設(shè)計(jì)如下案例，供大家思考驗(yàn)證。

/**
 * @author
 */
public class Demo03 {
    // 擴(kuò)容機(jī)制
    public static void main(String[] args) {
	//無(wú)參構(gòu)造方法，初始容量默認(rèn)為16
	StringBuffer sb = new StringBuffer();
	//使用StringBuffer的capacity()方法查看其當(dāng)前容量
	System.out.println("默認(rèn)初始化容量capacity=" + sb.capacity() + ",默認(rèn)長(zhǎng)度length=" + sb.length());

	//一次追加20個(gè)字符，因?yàn)槌^了初始容量，因此會(huì)擴(kuò)容16*2+2=34
	sb.append("11111111112222222222");
	System.out.println("擴(kuò)容一次的capacity()=" + sb.capacity() + ",擴(kuò)容一次后的length=" + sb.length());
	StringBuffer sb02 = new StringBuffer();
	//再次添加50個(gè)字符，不僅超過了初始容量16，而且按照 當(dāng)前容量*2+2 進(jìn)行擴(kuò)容(34)后，依然存儲(chǔ)不下，
        //則直接將容量擴(kuò)容到新追加的字符串長(zhǎng)度50
	sb02.append("11111111112222222222333333333344444444445555555555");	
	System.out.println("再次擴(kuò)容后的capacity="+sb02.capacity()+",再次擴(kuò)容后的長(zhǎng)度length():"+sb02.length());
    }
}

從上述實(shí)驗(yàn)的執(zhí)行結(jié)果中，你會(huì)發(fā)現(xiàn)StringBuffer與StringBuilder就是按照上述規(guī)則進(jìn)行擴(kuò)容的。

五. 結(jié)語(yǔ)

至此，我們就把字符串相關(guān)的內(nèi)容都學(xué)習(xí)完了，接下來(lái)就把今天的重點(diǎn)內(nèi)容給大家總結(jié)一下，尤其是String、StringBuffer與StringBuilder的區(qū)別有哪些。

1. 相同點(diǎn)

String、StringBuffer、StringBuilder三者共同之處，它們都是final類，不允許被繼承，這樣設(shè)計(jì)主要是從性能和安全性上考慮的。

2. 不同點(diǎn)

String、StringBuffer、StringBuilder這三個(gè)類之間的區(qū)別主要體現(xiàn)在3個(gè)方面，即 運(yùn)行速度、線程安全、功能、可變性 這4個(gè)方面。

在運(yùn)行速度方面： 三者之間的執(zhí)行速度由快到慢為：StringBuilder > StringBuffer > String

在線程安全方面： StringBuilder是線程不安全的，而StringBuffer是線程安全的。 如果一個(gè)StringBuffer對(duì)象在字符串緩沖區(qū)被多個(gè)線程使用，StringBuffer中很多方法都帶有synchronized關(guān)鍵字，可以保證線程是安全的。但StringBuilder的方法中則沒有該關(guān)鍵字，所以不能保證線程安全，有可能在進(jìn)行線程并發(fā)操作時(shí)產(chǎn)生一些異常。所以如果要進(jìn)行多線程環(huán)境下的操作，考慮使用StringBuffer；在單線程環(huán)境下，建議使用速度StringBuilder。

在功能方面： String實(shí)現(xiàn)了三個(gè)接口，即Serializable、Comparable、CarSequence； StringBuilder和StringBuffer實(shí)現(xiàn)了兩個(gè)接口，Serializable、CharSequence，相比之下String的實(shí)例可以通過compareTo方法進(jìn)行比較，其他兩個(gè)不可以。

在可變性方面：String字符串是不可變的，StringBuilder與StringBuffer是可變的。

3. 最后總結(jié)一下

String： 適用于少量字符串操作的情況；

StringBuilder：適用于單線程環(huán)境下，在字符緩沖區(qū)進(jìn)行大量操作的情況；

StringBuffer： 適用多線程環(huán)境下，在字符緩沖區(qū)進(jìn)行大量操作的情況；

使用場(chǎng)景 ： 當(dāng)修改字符串的操作比較多時(shí)，可以使用StringBuilder或StringBuffer；在要求線程安全的情況下用StringBuffer，在不要求線程安全的情況下用StringBuilder。

以上就是Java中StringBuilder與StringBuffer使用及源碼解讀的詳細(xì)內(nèi)容，更多關(guān)于Java StringBuilder與StringBuffer的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！