Java中五種拼接字符串方式的解讀

1. 使用 + 拼接字符串，其實只是Java提供的一個語法糖，那麼，咱們就來解一解這個語法糖，看看他的內部原理究竟是如何實現的。

    這樣一段代碼，咱們把它生成的字節碼進行反編譯，看看結果。

    

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

    反編譯後的代碼塊

String wechat = "Hollis";
String introduce = "\u6BCF\u65E5\u66F4\u65B0Java\u76F8\u5173\u6280\u672F\u6587\u7AE0";
String hollis = (new StringBuilder()).append(wechat).append(",").append(introduce).toString();

經過查看反編譯之後的代碼，咱們能夠發現，原來字符串常量在拼接過程當中，是將String轉成了StringBuilder後，使用其append方法進行處理的。

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

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

3. StringBuffer和StringBuilder

    和String類相似，StringBuilder類也封裝了一個字符數組, 與String不一樣的是，它並非final的，因此他是能夠修改的。另外，與String不一樣，字符數組中不必定全部位置都已經被使用，它有一個實例變量，表示數組中已經使用的字符個數

其append源碼以下

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

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則不是線程安全的。

4. StringUtils.join

    經過查看StringUtils.join的源代碼，咱們能夠發現，其實他也是經過StringBuilder來實現的。

public static String join(final double[] array, final char separator, final int startIndex, final int endIndex) {
       if (array == null) {
           return null;
       }
       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);
           }
           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));

+ 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 方法進行擴展。而不要使用+。