字串拼接的幾種方式和區別

　　字串，是Java中最常用的一個數據型別了。

　　本文，也是對於Java中字串相關知識的一個補充，主要來介紹一下字串拼接相關的知識。本文基於jdk1.8.0_181。

字串拼接

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

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

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

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

　　字串不變性與字串拼接

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

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

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

　　s中儲存的是一個重新創建出來的String物件的引用。

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

使用+拼接字串

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

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

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

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

StringBuffer

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

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

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

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

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

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

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

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

String []list  ={"Hello","World"};
String result= StringUtils.join(list,",");
System.out.println(result);
//結果：Hello,World

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

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

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

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

　　關於這個知識點，前面的章節介紹過，主要是通過StringBuilder的append方法實現的。

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，這也就呼應到前面我們說的字串的不變性問題上了。

StringBuffer和StringBuilder

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

　　和String類類似，StringBuilder類也封裝了一個字元陣列，定義如下：

char[] value;

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

int count;

　　其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則不是執行緒安全的。

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

效率比較

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

long t1 = System.currentTimeMillis();
//這裡是初始字串定義
for (int i = 0; i < 50000; i++) {
    //這裡是字串拼接程式碼
}
long t2 = System.currentTimeMillis();
System.out.println("cost:" + (t2 - t1));複製ErrorOK!
我們使用形如以上形式的程式碼，分別測試下五種字串拼接程式碼的執行時間。得到結果如下：

+ 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。