關于 Java 字符串拼接的幾種方式以及性能比較

一、字符串拼接

字符串拼接是我們在Java代碼中比較經常要做的事情，就是把多個字符串拼接到一起。

我們都知道，String 是 Java 中一個不可變的類，所以他一旦被實例化就無法被修改。

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

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

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

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

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

其實最后我們得到的s已經是一個新的字符串了。如下圖

image

s 中保存的是一個重新創建出來的 String 對象的引用。

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

2. 使用+拼接字符串

在 Java 中，拼接字符串最簡單的方式就是直接使用符號+來拼接。如：

String wechat = "Hollis";
String introduce = "每日更新Java相關技術文章";
String hollis = wechat + "," + introduce;

這里要特別說明一點，有人把 Java 中使用+拼接字符串的功能理解為運算符重載。其實并不是，Java是不支持運算符重載的。這其實只是 Java 提供的一個語法糖。后面再詳細介紹。

運算符重載：在計算機程序設計中，運算符重載（英語：operator overloading）是多態的一種。運算符重載，就是對已有的運算符重新進行定義，賦予其另一種功能，以適應不同的數據類型。

語法糖：語法糖（Syntactic sugar），也譯為糖衣語法，是由英國計算機科學家彼得·蘭丁發明的一個術語，指計算機語言中添加的某種語法，這種語法對語言的功能沒有影響，但是更方便程序員使用。語法糖讓程序更加簡潔，有更高的可讀性。

3. concat

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

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

4. StringBuffer

關于字符串，Java中除了定義了一個可以用來定義字符串常量的String類以外，還提供了可以用來定義字符串變量的StringBuffer類，它的對象是可以擴充和修改的。

使用StringBuffer可以方便的對字符串進行拼接。如：

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

5. StringBuilder

除了StringBuffer以外，還有一個類StringBuilder也可以使用，其用法和StringBuffer類似。如：

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

6. StringUtils.join

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

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

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

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

并且，Java8 中的 String 類中也提供了一個靜態的 join 方法，用法和StringUtils.join類似。

以上就是比較常用的五種在 Java 種拼接字符串的方式，那么到底哪種更好用呢？為什么阿里巴巴 Java 開發手冊中不建議在循環體中使用+進行字符串拼接呢？

image

(阿里巴巴Java開發手冊中關于字符串拼接的規約)

二、使用+拼接字符串的實現原理

前面提到過，使用+拼接字符串，其實只是Java提供的一個語法糖， 那么，我們就來解一解這個語法糖，看看他的內部原理到底是如何實現的。

還是這樣一段代碼。我們把他生成的字節碼進行反編譯，看看結果。

String wechat = "Hollis";
String introduce = "每日更新Java相關技術文章";
String hollis = wechat + "," + introduce;

反編譯后的內容如下，反編譯工具為jad。

String wechat = "Hollis";
String introduce = "\u6BCF\u65E5\u66F4\u65B0Java\u76F8\u5173\u6280\u672F\u6587\u7AE0";//每日更新Java相關技術文章
String hollis = (new StringBuilder()).append(wechat).append(",").append(introduce).toString();

通過查看反編譯以后的代碼，我們可以發現，原來字符串常量在拼接過程中，是將 String 轉成了 StringBuilder 后，使用其 append 方法進行處理的。

那么也就是說，Java 中的+對字符串的拼接，其實現原理是使用StringBuilder.append。

1. concat是如何實現的

我們再來看一下concat方法的源代碼，看一下這個方法又是如何實現的。

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);
}

這段代碼首先創建了一個字符數組，長度是已有字符串和待拼接字符串的長度之和，再把兩個字符串的值復制到新的字符數組中，并使用這個字符數組創建一個新的 String 對象并返回。

通過源碼我們也可以看到，經過 concat 方法，其實是new了一個新的 String，這也就呼應到前面我們說的字符串的不變性問題上了。

2. StringBuffer和StringBuilder

接下來我們看看StringBuffer和StringBuilder的實現原理。

和String類類似，StringBuilder類也封裝了一個字符數組，定義如下：

char[]value;

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

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 會直接拷貝字符到內部的字符數組中，如果字符數組長度不夠，會進行擴展。

StringBuffer和StringBuilder類似，最大的區別就是StringBuffer是線程安全的，看一下StringBuffer的append方法。

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

該方法使用synchronized進行聲明，說明是一個線程安全的方法。而StringBuilder則不是線程安全的。

3. StringUtils.join是如何實現的

通過查看StringUtils.join的源代碼，我們可以發現，其實他也是通過StringBuilder來實現的。

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包中的一個類，用于構造一個由分隔符分隔的字符序列（可選），并且可以從提供的前綴開始并以提供的后綴結尾。雖然這也可以在StringBuilder類的幫助下在每個字符串之后附加分隔符，但 StringJoiner 提供了簡單的方法來實現，而無需編寫大量代碼。

StringJoiner類共有2個構造函數，5個公有方法。其中最常用的方法就是add方法和toString方法，類似于 StringBuilder 中的append方法和toString方法。

4.1 用法

StringJoiner 的用法比較簡單，下面的代碼中，我們使用 StringJoiner 進行了字符串拼接。

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());
    }
}

以上代碼輸出結果：

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

值得注意的是，當我們StringJoiner(CharSequence delimiter)初始化一個StringJoiner的時候，這個delimiter其實是分隔符，并不是可變字符串的初始值。

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

4.2 原理

介紹了簡單的用法之后，我們再來看看這個StringJoiner的原理，看看他到底是如何實現的。主要看一下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;
}

看到了一個熟悉的身影——StringBuilder ，沒錯，StringJoiner 其實就是依賴 StringBuilder 實現的

4.3 為什么需要 StringJoiner

試想，在 Java 中，如果我們有這樣一個 List：

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

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

Hollis,hollischuang,Java干貨

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

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

即可。上面用的表達式中，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);
}

其實現原理就是借助了StringJoiner。

當然，或許在Collector中直接使用StringBuilder似乎也可以實現類似的功能，只不過稍微麻煩一些。所以，Java 8中提供了StringJoiner來豐富Stream的用法。

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

4.4 StirngJoiner 總結

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

StringJoiner 其實是通過 StringBuilder 實現的，所以他的性能和 StringBuilder 差不多，也是非線程安全的。

如果日常開發中中，需要進行字符串拼接，如何選擇？

  • 如果只是簡單的字符串拼接，考慮直接使用+即可。
  • 如果是在 for 循環中進行字符串拼接，考慮使用StringBuilder和StringBuffer。
  • 如果是通過一個List進行字符串拼接，則考慮使用StringJoiner。

三、效率比較

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

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

我們使用形如以上形式的代碼，分別測試下五種字符串拼接代碼的運行時間。得到結果如下：

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

從結果可以看出，用時從短到長的對比是：

StringBuilder < StringBuffer < concat < + <StringUtils.join

StringBuffer在StringBuilder的基礎上，做了同步處理，所以在耗時上會相對多一些。

StringUtils.join 也是使用了 StringBuilder，并且其中還是有很多其他操作，所以耗時較長，這個也容易理解。其實 StringUtils.join 更擅長處理字符串數組或者列表的拼接。

那么問題來了，前面我們分析過，其實使用+拼接字符串的實現原理也是使用的StringBuilder，那為什么結果相差這么多，高達1000多倍呢？

我們再把以下代碼反編譯下：

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循環中，每次都是new了一個StringBuilder，然后再把String轉成StringBuilder，再進行append。

而頻繁的新建對象當然要耗費很多時間了，不僅僅會耗費時間，頻繁的創建對象，還會造成內存資源的浪費。

所以，阿里巴巴Java開發手冊建議：循環體內，字符串的連接方式，使用 StringBuilder 的 append 方法進行擴展。而不要使用+。

四、總結

本文介紹了什么是字符串拼接，雖然字符串是不可變的，但是還是可以通過新建字符串的方式來進行字符串的拼接。

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

由于字符串拼接過程中會創建新的對象，所以如果要在一個循環體中進行字符串拼接，就要考慮內存問題和效率問題。

因此，經過對比，我們發現，直接使用StringBuilder的方式是效率最高的。因為StringBuilder天生就是設計來定義可變字符串和字符串的變化操作的。

但是，還要強調的是：

  1. 如果不是在循環體中進行字符串拼接的話，直接使用+就好了。

  2. 如果在并發場景中進行字符串拼接的話，要使用StringBuffer來代替StringBuilder。

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

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。