一栅螟、字符串拼接

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

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

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

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

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

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

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

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

image

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

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

2. 使用+拼接字符串

在 Java 中抒痒，拼接字符串最簡單的方式就是直接使用符號(hào)+來拼接幌绍。如：

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

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

運(yùn)算符重載：在計(jì)算機(jī)程序設(shè)計(jì)中誓酒，運(yùn)算符重載（英語：operator overloading）是多態(tài)的一種。運(yùn)算符重載贮聂，就是對(duì)已有的運(yùn)算符重新進(jìn)行定義靠柑，賦予其另一種功能，以適應(yīng)不同的數(shù)據(jù)類型吓懈。

語法糖：語法糖（Syntactic sugar）歼冰，也譯為糖衣語法，是由英國計(jì)算機(jī)科學(xué)家彼得·蘭丁發(fā)明的一個(gè)術(shù)語骄瓣，指計(jì)算機(jī)語言中添加的某種語法停巷，這種語法對(duì)語言的功能沒有影響，但是更方便程序員使用榕栏。語法糖讓程序更加簡潔畔勤，有更高的可讀性。

3. concat

除了使用+拼接字符串之外扒磁，還可以使用String類中的方法 concat 方法來拼接字符串庆揪。如：

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

4. StringBuffer

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

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

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

5. StringBuilder

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

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

6. StringUtils.join

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

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

這里簡單說一下，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 類中也提供了一個(gè)靜態(tài)的 join 方法形帮，用法和StringUtils.join類似槽惫。

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

image

(阿里巴巴Java開發(fā)手冊(cè)中關(guān)于字符串拼接的規(guī)約)

二则吟、使用+拼接字符串的實(shí)現(xiàn)原理

前面提到過槐臀，使用+拼接字符串锄蹂，其實(shí)只是Java提供的一個(gè)語法糖， 那么水慨，我們就來解一解這個(gè)語法糖得糜，看看他的內(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 = "\u6BCF\u65E5\u66F4\u65B0Java\u76F8\u5173\u6280\u672F\u6587\u7AE0";//每日更新Java相關(guān)技術(shù)文章
String hollis = (new StringBuilder()).append(wechat).append(",").append(introduce).toString();

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

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

1. concat是如何實(shí)現(xiàn)的

我們?cè)賮砜匆幌耤oncat方法的源代碼华畏，看一下這個(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ù)組尊蚁，長度是已有字符串和待拼接字符串的長度之和亡笑，再把兩個(gè)字符串的值復(fù)制到新的字符數(shù)組中，并使用這個(gè)字符數(shù)組創(chuàng)建一個(gè)新的 String 對(duì)象并返回横朋。

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

2. StringBuffer和StringBuilder

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

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

char[]value;

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

intcount;

其 append 源碼如下：

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

該類繼承了AbstractStringBuilder類皮获，看下其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ù)組長度不夠，會(huì)進(jìn)行擴(kuò)展洒宝。

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

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

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

3. StringUtils.join是如何實(shí)現(xiàn)的

通過查看StringUtils.join的源代碼比庄，我們可以發(fā)現(xiàn)，其實(shí)他也是通過StringBuilder來實(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();
}

4. StringJoiner

StringJoiner 是 java.util包中的一個(gè)類佳窑，用于構(gòu)造一個(gè)由分隔符分隔的字符序列（可選），并且可以從提供的前綴開始并以提供的后綴結(jié)尾丑勤。雖然這也可以在StringBuilder類的幫助下在每個(gè)字符串之后附加分隔符华嘹，但 StringJoiner 提供了簡單的方法來實(shí)現(xiàn)，而無需編寫大量代碼法竞。

StringJoiner類共有2個(gè)構(gòu)造函數(shù)耙厚，5個(gè)公有方法。其中最常用的方法就是add方法和toString方法岔霸，類似于 StringBuilder 中的append方法和toString方法薛躬。

4.1 用法

StringJoiner 的用法比較簡單，下面的代碼中呆细，我們使用 StringJoiner 進(jìn)行了字符串拼接型宝。

public class StringJoinerTest {

    public static void main(String[] args) {
        StringJoiner sj = new StringJoiner("Hollis");

        sj.add("hollischuang");
        sj.add("Java干貨");
        System.out.println(sj.toString());

        StringJoiner sj1 = new StringJoiner(":","[","]");

        sj1.add("Hollis").add("hollischuang").add("Java干貨");
        System.out.println(sj1.toString());
    }
}

以上代碼輸出結(jié)果：

hollischuangHollisJava干貨
[Hollis:hollischuang:Java干貨]

值得注意的是，當(dāng)我們StringJoiner(CharSequence delimiter)初始化一個(gè)StringJoiner的時(shí)候絮爷，這個(gè)delimiter其實(shí)是分隔符趴酣，并不是可變字符串的初始值。

StringJoiner(CharSequence delimiter,CharSequence prefix,CharSequence suffix)的第二個(gè)和第三個(gè)參數(shù)分別是拼接后的字符串的前綴和后綴坑夯。

4.2 原理

介紹了簡單的用法之后岖寞，我們?cè)賮砜纯催@個(gè)StringJoiner的原理，看看他到底是如何實(shí)現(xiàn)的柜蜈。主要看一下add方法：

public StringJoiner add(CharSequence newElement) {
    prepareBuilder().append(newElement);
    return this;
}

private StringBuilder prepareBuilder() {
    if (value != null) {
        value.append(delimiter);
    } else {
        value = new StringBuilder().append(prefix);
    }
    return value;
}

看到了一個(gè)熟悉的身影——StringBuilder 仗谆，沒錯(cuò)指巡，StringJoiner 其實(shí)就是依賴 StringBuilder 實(shí)現(xiàn)的

4.3 為什么需要 StringJoiner

試想，在 Java 中隶垮，如果我們有這樣一個(gè) List：

List<String> list = ImmutableList.of("Hollis","hollischuang","Java干貨");

如果我們想要把他拼接成一個(gè)以下形式的字符串：

Hollis,hollischuang,Java干貨

以上需求只需要一行代碼：

list.stream().collect(Collectors.joining(":"))

即可藻雪。上面用的表達(dá)式中，Collectors.joining的源代碼如下：

public static Collector<CharSequence, ?, String> joining(CharSequence delimiter,
                                                         CharSequence prefix,
                                                         CharSequence suffix) {
    return new CollectorImpl<>(
            () -> new StringJoiner(delimiter, prefix, suffix),
            StringJoiner::add, StringJoiner::merge,
            StringJoiner::toString, CH_NOID);
}

其實(shí)現(xiàn)原理就是借助了StringJoiner狸吞。

當(dāng)然勉耀，或許在Collector中直接使用StringBuilder似乎也可以實(shí)現(xiàn)類似的功能，只不過稍微麻煩一些捷绒。所以瑰排，Java 8中提供了StringJoiner來豐富Stream的用法。

而且StringJoiner也可以方便的增加前綴和后綴暖侨，比如我們希望得到的字符串是[Hollis,hollischuang,Java干貨]而不是Hollis,hollischuang,Java干貨的話，StringJoiner的優(yōu)勢(shì)就更加明顯了崇渗。

4.4 StirngJoiner 總結(jié)

Java 8 中提供的可變字符串類——StringJoiner字逗，可以用于字符串拼接。

StringJoiner 其實(shí)是通過 StringBuilder 實(shí)現(xiàn)的宅广，所以他的性能和 StringBuilder 差不多葫掉，也是非線程安全的。

如果日常開發(fā)中中跟狱，需要進(jìn)行字符串拼接俭厚，如何選擇？

• 如果只是簡單的字符串拼接驶臊，考慮直接使用+即可挪挤。
• 如果是在 for 循環(huán)中進(jìn)行字符串拼接，考慮使用StringBuilder和StringBuffer关翎。
• 如果是通過一個(gè)List進(jìn)行字符串拼接扛门，則考慮使用StringJoiner。

三纵寝、效率比較

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

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

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

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

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

StringBuilder < StringBuffer < concat < + <StringUtils.join

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

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

那么問題來了，前面我們分析過址否，其實(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開發(fā)手冊(cè)建議：循環(huán)體內(nèi)必指，字符串的連接方式囊咏，使用 StringBuilder 的 append 方法進(jìn)行擴(kuò)展。而不要使用+塔橡。

四梅割、總結(jié)

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

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

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

因此殊校，經(jīng)過對(duì)比，我們發(fā)現(xiàn)读存，直接使用StringBuilder的方式是效率最高的为流。因?yàn)?code>StringBuilder天生就是設(shè)計(jì)來定義可變字符串和字符串的變化操作的呕屎。

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

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

2. 如果在并發(fā)場景中進(jìn)行字符串拼接的話，要使用StringBuffer來代替StringBuilder莲祸。

原文：https://www.hollischuang.com/archives/3186