爲何阿里巴巴不建議在for循環中使用"+"進行字符串拼接

本文轉自：微信公衆號-Hollis

 

 

1、字符串拼接

 

字符串拼接是咱們在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;

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

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

 

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

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  ={"Hollis","每日更新Java相關技術文章"}; String result= StringUtils.join(list,","); System.out.println(result); //結果：Hollis,每日更新Java相關技術文章

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

以上就是比較經常使用的五種在Java種拼接字符串的方式，那麼到底哪一種更好用呢？爲何阿里巴巴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。

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

總結

本文介紹了什麼是字符串拼接，雖然字符串是不可變的，可是仍是能夠經過新建字符串的方式來進行字符串的拼接。

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

因爲字符串拼接過程當中會建立新的對象，因此若是要在一個循環體中進行字符串拼接，就要考慮內存問題和效率問題。

所以，通過對比，咱們發現，直接使用StringBuilder的方式是效率最高的。由於StringBuilder天生就是設計來定義可變字符串和字符串的變化操做的。

可是，還要強調的是：

一、若是不是在循環體中進行字符串拼接的話，直接使用+就行了。

二、若是在併發場景中進行字符串拼接的話，要使用StringBuffer來代替StringBuilder。