字符串拼接使用“+”還是StringBuilder

1、普通的幾個字符串拼接成一個字符串，直接使用“+”
因為教材等原因，當前依舊有許多人拼接字符串時認為使用“+”耗性能1，首選StringBuilder。

實際上，從JDK5開始，Java編譯器就做了優化，使用“+”拼接字符串，編譯器編譯后實際就自動優化為使用StringBuilder。

新建測試類StringTest，分別創建使用“+”拼接字符串和使用StringBuilder拼接字符串的方法；並新增Junit測試用例，分別調用拼接字符串100000次（這里不是循環拼接，而是執行多次拼接，因為一次拼接耗時太少，看不出差異），打印耗時。

 

    /**
     * 使用+拼接字符串
     */
    public String concatenationStringByPlus(String prefix, int i) {
        return prefix + "-" + i;
    }
 
    /**
     * 使用StringBuilder拼接字符串
     */
    public String concatenationStringByStringBuilder(String prefix, int i) {
        return new StringBuilder().append(prefix).append("-").append(i).toString();
    }
 
    /**
     * 測試使用+拼接字符串耗時
     */
    @Test
    public void testStringConcatenation01ByPlus() {
        long startTime = System.currentTimeMillis();
        int count = 100000;
        for (int i = 0; i < count; i++) {
            String str = concatenationStringByPlus("testStringConcatenation01ByStringBuilder:", i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("testStringConcatenation01ByPlus，拼接字符串" + count + "次，花費" + (endTime - startTime) + "秒");
    }
 
 
    /**
     * 測試使用StringBuilder拼接字符串耗時
     */
    @Test
    public void testStringConcatenation02ByStringBuilder() {
        long startTime = System.currentTimeMillis();
        int count = 100000;
        for (int i = 0; i < count; i++) {
            String str = concatenationStringByStringBuilder("testStringConcatenation02ByStringBuilder:", i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("testStringConcatenation02ByStringBuilder，拼接字符串" + count + "次，花費" + (endTime - startTime) + "秒");
    }

執行Junit用例，看耗時統計輸出：

testStringConcatenation01ByPlus，拼接字符串100000次，花費33秒
testStringConcatenation02ByStringBuilder，拼接字符串100000次，花費36秒

雖然有差異，但是差異極小，考慮到執行了100000次，每次耗時的差異就更小了，而且程序執行有各種因素影響執行效率，可以認為耗時差不多。也可以多次執行對比耗時差異，也可以發現基本一致。

到class文件所在目錄，執行 javap -c StringTest.class，對class文件進行反編譯，查看編譯后的代碼差異。這里不要使用Intellij idea和JD進行反編譯，因為反編譯有優化，會都反編譯成“+”拼接的，看不出來編譯后的真正情況。

 

從圖上可以看出兩種拼接方法反編譯后完全一樣，沒有差異，執行效率自然也是一樣的。

既然執行效率一樣，從代碼簡潔利於閱讀考慮，推薦使用“+”拼接字符串。

2、循環拼接一個字符串，使用StringBuilder

循環拼接，雖然“+”拼接字符串編譯后也會變成StringBuilder，但是每次循環處理都會new一個StringBuilder對象，耗時會大大增加。而直接使用StringBuilder，new一次就可以了，效率相對高。

新增2個Junit測試用例，循環拼接10000次拼接一個字符串（次數少於上面的用例，因為拼接的是一個字符串，如果拼接次數太多，可能引發內存溢出）：

/**
     * 循環使用+拼接字符串
     */
    @Test
    public void testLoopStringConcatenation03ByPlus() {
        long startTime = System.currentTimeMillis();
        int count = 10000;
        String str = "testLoopStringConcatenation03ByPlus:";
        for (int i = 0; i < count; i++) {
            str = str + "-" + i;
        }
        System.out.println(str);
        long endTime = System.currentTimeMillis();
        System.out.println("testLoopStringConcatenation03ByPlus，拼接字符串" + count + "次，花費" + (endTime - startTime) + "秒");
    }
 
    /**
     * 測試循環使用StringBuilder拼接字符串耗時
     */
    @Test
    public void testLoopStringConcatenation04ByStringBuilder() {
        long startTime = System.currentTimeMillis();
        int count = 100000;
        StringBuilder stringBuilder = new StringBuilder("testLoopStringConcatenation04ByStringBuilder:");
        for (int i = 0; i < count; i++) {
            stringBuilder.append("-");
            stringBuilder.append(i);
        }
        String str = stringBuilder.toString();
        System.out.println(str);
        long endTime = System.currentTimeMillis();
        System.out.println("testLoopStringConcatenation04ByStringBuilder，拼接字符串" + count + "次，花費" + (endTime - startTime) + "秒");
    }

執行Junit用例，看耗時統計輸出：

testLoopStringConcatenation03ByPlus，拼接字符串10000次，花費463秒
testLoopStringConcatenation04ByStringBuilder，拼接字符串10000次，花費13秒

可以看出，差異明顯，不在一個量級了。

循環拼接時使用“+”拼接字符串效率較低，推薦使用StringBuilder拼接字符串。

 
————————————————
版權聲明：本文為CSDN博主「巨堅強」（作者本人）的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/AOBO516/article/details/103915978