字符串拼接的幾種方式和區別
字符串，是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。