摘要：使用可以方便的對(duì)字符串進(jìn)行拼接。該方法使用進(jìn)行聲明，說(shuō)明是一個(gè)線程安全的方法。所以，阿里巴巴開(kāi)發(fā)手冊(cè)建議循環(huán)體內(nèi)，字符串的連接方式，使用的方法進(jìn)行擴(kuò)展。但是，還要強(qiáng)調(diào)的是如果不是在循環(huán)體中進(jìn)行字符串拼接的話(huà)，直接使用就好了。

摘要： 學(xué)習(xí)阿里巴巴Java開(kāi)發(fā)手冊(cè)。

原文：為什么阿里巴巴不建議在for循環(huán)中使用"+"進(jìn)行字符串拼接

微信公眾號(hào)：Hollis

Fundebug經(jīng)授權(quán)轉(zhuǎn)載，版權(quán)歸原作者所有。

字符串，是Java中最常用的一個(gè)數(shù)據(jù)類(lèi)型了。關(guān)于字符串的知識(shí)，作者已經(jīng)發(fā)表過(guò)幾篇文章介紹過(guò)很多，如：

Java 7 源碼學(xué)習(xí)系列（一）——String

該如何創(chuàng)建字符串，使用” “還是構(gòu)造函數(shù)？

我終于搞清楚了和String有關(guān)的那點(diǎn)事兒

三張圖徹底了解Java中字符串的不變性

為什么Java要把字符串設(shè)計(jì)成不可變的

三張圖徹底了解JDK 6和JDK 7中substring的原理及區(qū)別

Java中的Switch對(duì)整型、字符型、字符串型的具體實(shí)現(xiàn)細(xì)節(jié)

本文，也是對(duì)于Java中字符串相關(guān)知識(shí)的一個(gè)補(bǔ)充，主要來(lái)介紹一下字符串拼接相關(guān)的知識(shí)。本文基于jdk1.8.0_181。

字符串拼接是我們?cè)贘ava代碼中比較經(jīng)常要做的事情，就是把多個(gè)字符串拼接到一起。

我們都知道，String是Java中一個(gè)不可變的類(lèi)，所以他一旦被實(shí)例化就無(wú)法被修改。

不可變類(lèi)的實(shí)例一旦創(chuàng)建，其成員變量的值就不能被修改。這樣設(shè)計(jì)有很多好處，比如可以緩存hashcode、使用更加便利以及更加安全等。

但是，既然字符串是不可變的，那么字符串拼接又是怎么回事呢？

字符串不變性與字符串拼接

其實(shí)，所有的所謂字符串拼接，都是重新生成了一個(gè)新的字符串。下面一段字符串拼接代碼：

String s = "abcd";
s = s.concat("ef");

其實(shí)最后我們得到的s已經(jīng)是一個(gè)新的字符串了。如下圖

s中保存的是一個(gè)重新創(chuàng)建出來(lái)的String對(duì)象的引用。

那么，在Java中，到底如何進(jìn)行字符串拼接呢？字符串拼接有很多種方式，這里簡(jiǎn)單介紹幾種比較常用的。

使用+拼接字符串

在Java中，拼接字符串最簡(jiǎn)單的方式就是直接使用符號(hào)+來(lái)拼接。如：

String wechat = "Hollis";
String introduce = "每日更新Java相關(guān)技術(shù)文章";
String hollis = wechat + "," + introduce;

這里要特別說(shuō)明一點(diǎn)，有人把Java中使用+拼接字符串的功能理解為運(yùn)算符重載。其實(shí)并不是，Java是不支持運(yùn)算符重載的。這其實(shí)只是Java提供的一個(gè)語(yǔ)法糖。后面再詳細(xì)介紹。

運(yùn)算符重載：在計(jì)算機(jī)程序設(shè)計(jì)中，運(yùn)算符重載（英語(yǔ)：operator overloading）是多態(tài)的一種。運(yùn)算符重載，就是對(duì)已有的運(yùn)算符重新進(jìn)行定義，賦予其另一種功能，以適應(yīng)不同的數(shù)據(jù)類(lèi)型。
語(yǔ)法糖：語(yǔ)法糖（Syntactic sugar），也譯為糖衣語(yǔ)法，是由英國(guó)計(jì)算機(jī)科學(xué)家彼得·蘭丁發(fā)明的一個(gè)術(shù)語(yǔ)，指計(jì)算機(jī)語(yǔ)言中添加的某種語(yǔ)法，這種語(yǔ)法對(duì)語(yǔ)言的功能沒(méi)有影響，但是更方便程序員使用。語(yǔ)法糖讓程序更加簡(jiǎn)潔，有更高的可讀性。

concat
除了使用+拼接字符串之外，還可以使用String類(lèi)中的方法concat方法來(lái)拼接字符串。如：

String wechat = "Hollis";
String introduce = "每日更新Java相關(guān)技術(shù)文章";
String hollis = wechat.concat(",").concat(introduce);

StringBuffer

關(guān)于字符串，Java中除了定義了一個(gè)可以用來(lái)定義字符串常量的String類(lèi)以外，還提供了可以用來(lái)定義字符串變量的StringBuffer類(lèi)，它的對(duì)象是可以擴(kuò)充和修改的。

使用StringBuffer可以方便的對(duì)字符串進(jìn)行拼接。如：

StringBuffer wechat = new StringBuffer("Hollis");
String introduce = "每日更新Java相關(guān)技術(shù)文章";
StringBuffer hollis = wechat.append(",").append(introduce);

StringBuilder
除了StringBuffer以外，還有一個(gè)類(lèi)StringBuilder也可以使用，其用法和StringBuffer類(lèi)似。如：

StringBuilder wechat = new StringBuilder("Hollis");
String introduce = "每日更新Java相關(guān)技術(shù)文章";
StringBuilder hollis = wechat.append(",").append(introduce);

StringUtils.join
除了JDK中內(nèi)置的字符串拼接方法，還可以使用一些開(kāi)源類(lèi)庫(kù)中提供的字符串拼接方法名，如apache.commons中提供的StringUtils類(lèi)，其中的join方法可以拼接字符串。

String wechat = "Hollis";
String introduce = "每日更新Java相關(guān)技術(shù)文章";
System.out.println(StringUtils.join(wechat, ",", introduce));

這里簡(jiǎn)單說(shuō)一下，StringUtils中提供的join方法，最主要的功能是：將數(shù)組或集合以某拼接符拼接到一起形成新的字符串，如：

String []list  ={"Hollis","每日更新Java相關(guān)技術(shù)文章"};
String result= StringUtils.join(list,",");
System.out.println(result);
//結(jié)果：Hollis,每日更新Java相關(guān)技術(shù)文章

并且，Java8中的String類(lèi)中也提供了一個(gè)靜態(tài)的join方法，用法和StringUtils.join類(lèi)似。

以上就是比較常用的五種在Java種拼接字符串的方式，那么到底哪種更好用呢？為什么阿里巴巴Java開(kāi)發(fā)手冊(cè)中不建議在循環(huán)體中使用+進(jìn)行字符串拼接呢？

前面提到過(guò)，使用+拼接字符串，其實(shí)只是Java提供的一個(gè)語(yǔ)法糖， 那么，我們就來(lái)解一解這個(gè)語(yǔ)法糖，看看他的內(nèi)部原理到底是如何實(shí)現(xiàn)的。

還是這樣一段代碼。我們把他生成的字節(jié)碼進(jìn)行反編譯，看看結(jié)果。

String wechat = "Hollis";
String introduce = "每日更新Java相關(guān)技術(shù)文章";
String hollis = wechat + "," + introduce;

反編譯后的內(nèi)容如下，反編譯工具為jad。

String wechat = "Hollis";
String introduce = "u6BCFu65E5u66F4u65B0Javau76F8u5173u6280u672Fu6587u7AE0";//每日更新Java相關(guān)技術(shù)文章
String hollis = (new StringBuilder()).append(wechat).append(",").append(introduce).toString();

通過(guò)查看反編譯以后的代碼，我們可以發(fā)現(xiàn)，原來(lái)字符串常量在拼接過(guò)程中，是將String轉(zhuǎn)成了StringBuilder后，使用其append方法進(jìn)行處理的。

那么也就是說(shuō)，Java中的+對(duì)字符串的拼接，其實(shí)現(xiàn)原理是使用StringBuilder.append。

我們?cè)賮?lái)看一下concat方法的源代碼，看一下這個(gè)方法又是如何實(shí)現(xiàn)的。

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

這段代碼首先創(chuàng)建了一個(gè)字符數(shù)組，長(zhǎng)度是已有字符串和待拼接字符串的長(zhǎng)度之和，再把兩個(gè)字符串的值復(fù)制到新的字符數(shù)組中，并使用這個(gè)字符數(shù)組創(chuàng)建一個(gè)新的String對(duì)象并返回。

通過(guò)源碼我們也可以看到，經(jīng)過(guò)concat方法，其實(shí)是new了一個(gè)新的String，這也就呼應(yīng)到前面我們說(shuō)的字符串的不變性問(wèn)題上了。

接下來(lái)我們看看StringBuffer和StringBuilder的實(shí)現(xiàn)原理。

和String類(lèi)類(lèi)似，StringBuilder類(lèi)也封裝了一個(gè)字符數(shù)組，定義如下：

char[] value;

與String不同的是，它并不是final的，所以他是可以修改的。另外，與String不同，字符數(shù)組中不一定所有位置都已經(jīng)被使用，它有一個(gè)實(shí)例變量，表示數(shù)組中已經(jīng)使用的字符個(gè)數(shù)，定義如下：

int count;

其append源碼如下：

public StringBuilder append(String str) {
    super.append(str);
    return this;
}

該類(lèi)繼承了AbstractStringBuilder類(lèi)，看下其append方法：

public AbstractStringBuilder append(String str) {
    if (str == null)
        return appendNull();
    int len = str.length();
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    count += len;
    return this;
}

append會(huì)直接拷貝字符到內(nèi)部的字符數(shù)組中，如果字符數(shù)組長(zhǎng)度不夠，會(huì)進(jìn)行擴(kuò)展。

StringBuffer和StringBuilder類(lèi)似，最大的區(qū)別就是StringBuffer是線程安全的，看一下StringBuffer的append方法。

public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

該方法使用synchronized進(jìn)行聲明，說(shuō)明是一個(gè)線程安全的方法。而StringBuilder則不是線程安全的。

通過(guò)查看StringUtils.join的源代碼，我們可以發(fā)現(xiàn)，其實(shí)他也是通過(guò)StringBuilder來(lái)實(shí)現(xiàn)的。

public static String join(final Object[] array, String separator, final int startIndex, final int endIndex) {
    if (array == null) {
        return null;
    }
    if (separator == null) {
        separator = EMPTY;
    }

    // endIndex - startIndex > 0:   Len = NofStrings *(len(firstString) + len(separator))
    //           (Assuming that all Strings are roughly equally long)
    final int noOfItems = endIndex - startIndex;
    if (noOfItems <= 0) {
        return EMPTY;
    }

    final StringBuilder buf = new StringBuilder(noOfItems * 16);

    for (int i = startIndex; i < endIndex; i++) {
        if (i > startIndex) {
            buf.append(separator);
        }
        if (array[i] != null) {
            buf.append(array[i]);
        }
    }
    return buf.toString();
}

既然有這么多種字符串拼接的方法，那么到底哪一種效率最高呢？我們來(lái)簡(jiǎn)單對(duì)比一下。

long t1 = System.currentTimeMillis();
//這里是初始字符串定義
for (int i = 0; i < 50000; i++) {
    //這里是字符串拼接代碼
}
long t2 = System.currentTimeMillis();
System.out.println("cost:" + (t2 - t1));

我們使用形如以上形式的代碼，分別測(cè)試下五種字符串拼接代碼的運(yùn)行時(shí)間。得到結(jié)果如下：

+ cost:5119
StringBuilder cost:3
StringBuffer cost:4
concat cost:3623
StringUtils.join cost:25726

從結(jié)果可以看出，用時(shí)從短到長(zhǎng)的對(duì)比是：

StringBuilder`<`StringBuffer`<`concat`<`+`<`StringUtils.join

StringBuffer在StringBuilder的基礎(chǔ)上，做了同步處理，所以在耗時(shí)上會(huì)相對(duì)多一些。

StringUtils.join也是使用了StringBuilder，并且其中還是有很多其他操作，所以耗時(shí)較長(zhǎng)，這個(gè)也容易理解。其實(shí)StringUtils.join更擅長(zhǎng)處理字符串?dāng)?shù)組或者列表的拼接。

那么問(wèn)題來(lái)了，前面我們分析過(guò)，其實(shí)使用+拼接字符串的實(shí)現(xiàn)原理也是使用的StringBuilder，那為什么結(jié)果相差這么多，高達(dá)1000多倍呢？

我們?cè)侔岩韵麓a反編譯下：

long t1 = System.currentTimeMillis();
String str = "hollis";
for (int i = 0; i < 50000; i++) {
    String s = String.valueOf(i);
    str += s;
}
long t2 = System.currentTimeMillis();
System.out.println("+ cost:" + (t2 - t1));

反編譯后代碼如下：

long t1 = System.currentTimeMillis();
String str = "hollis";
for(int i = 0; i < 50000; i++)
{
    String s = String.valueOf(i);
    str = (new StringBuilder()).append(str).append(s).toString();
}

long t2 = System.currentTimeMillis();
System.out.println((new StringBuilder()).append("+ cost:").append(t2 - t1).toString());

我們可以看到，反編譯后的代碼，在for循環(huán)中，每次都是new了一個(gè)StringBuilder，然后再把String轉(zhuǎn)成StringBuilder，再進(jìn)行append。

而頻繁的新建對(duì)象當(dāng)然要耗費(fèi)很多時(shí)間了，不僅僅會(huì)耗費(fèi)時(shí)間，頻繁的創(chuàng)建對(duì)象，還會(huì)造成內(nèi)存資源的浪費(fèi)。

所以，阿里巴巴Java開(kāi)發(fā)手冊(cè)建議：循環(huán)體內(nèi)，字符串的連接方式，使用 StringBuilder 的 append 方法進(jìn)行擴(kuò)展。而不要使用+。

本文介紹了什么是字符串拼接，雖然字符串是不可變的，但是還是可以通過(guò)新建字符串的方式來(lái)進(jìn)行字符串的拼接。

常用的字符串拼接方式有五種，分別是使用+、使用concat、使用StringBuilder、使用StringBuffer以及使用StringUtils.join。

由于字符串拼接過(guò)程中會(huì)創(chuàng)建新的對(duì)象，所以如果要在一個(gè)循環(huán)體中進(jìn)行字符串拼接，就要考慮內(nèi)存問(wèn)題和效率問(wèn)題。

因此，經(jīng)過(guò)對(duì)比，我們發(fā)現(xiàn)，直接使用StringBuilder的方式是效率最高的。因?yàn)?b>StringBuilder天生就是設(shè)計(jì)來(lái)定義可變字符串和字符串的變化操作的。

但是，還要強(qiáng)調(diào)的是：

如果不是在循環(huán)體中進(jìn)行字符串拼接的話(huà)，直接使用+就好了。

如果在并發(fā)場(chǎng)景中進(jìn)行字符串拼接的話(huà)，要使用StringBuffer來(lái)代替StringBuilder。