為什麼不建議在for循環中使用"+"進行字元串拼接

2019 年 12 月 30 日
筆記

摘要： 學習阿里巴巴Java開發手冊。

原文：為什麼阿里巴巴不建議在for循環中使用」+」進行字元串拼接
微信公眾號：Hollis

Fundebug經授權轉載，版權歸原作者所有。

字元串，是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;

這裡要特別說明一點，有人把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 = "u6BCFu65E5u66F4u65B0Javau76F8u5173u6280u672Fu6587u7AE0";//每日更新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 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));

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

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

版權聲明

轉載時請註明作者 Fundebug以及本文地址： https://blog.fundebug.com/2019/01/23/not-use-add-concat-java-string-in-for-loop/

您的用戶遇到BUG了嗎？

體驗Demo 免費使用