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

作者：Hollis

本文，也是對于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開發手冊中關于字元串拼接的規約)

使用+拼接字元串的實作原理

前面提到過，使用+拼接字元串，其實隻是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 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

從結果可以看出，用時從短到長的對比是：

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。

來源 | HollisChuang's Blog

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

字元串拼接

字元串不變性與字元串拼接

使用+拼接字元串

concat

StringBuffer

StringBuilder

StringUtils.join

使用+拼接字元串的實作原理

concat是如何實作的

StringBuffer和StringBuilder

StringUtils.join是如何實作的

效率比較

總結

繼續閱讀

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

面試題解析：你接口測試是怎麼做的？

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method