你還在 for 回圈里使用 + 拼接字串？明天不用來上班了！-有解無憂

作者：后青春期的Keats
鏈接：https://www.cnblogs.com/keatsCoder/

引言

都說 StringBuilder 在處理字串拼接上效率要強于 String，但有時候我們的理解可能會存在一定的偏差，最近我在測驗資料匯入效率的時候就發現我以前對 StringBuilder 的部分理解是錯誤的，

后來我通過實踐測驗 + 找原理的方式搞清楚了這塊的邏輯，現在將程序分享給大家

測驗用例

我們的代碼在回圈中拼接字串一般有兩種情況

第一種就是每次回圈將物件中的幾個欄位拼接成一個新欄位，再賦值給物件
第二種操作是在回圈外創建一個字串物件，每次回圈向該字串拼接新的內容，回圈結束后得到拼接好的字串

對于這兩種情況，我創建了兩個對照組

第一組：

在每次 For 回圈中拼接字串，即拼即用、用完即毀，分別使用 String 和 StringBuilder 拼接

/**
 * 回圈內 String 拼接字串，一次回圈后銷毀
 */
public static void useString(){
    for (int i = 0; i < CYCLE_NUM_BIGGER; i++) {
        String str = str1 + i + str2 + i + str3 + i + str4 ;
    }
}

/**
 * 回圈內 使用 StringBuilder 拼接字串，一次回圈后銷毀
 */
public static void useStringBuilder(){
    for (int i = 0; i < CYCLE_NUM_BIGGER; i++) {
        StringBuilder sb = new StringBuilder();
        String s = sb.append(str1).append(i).append(str2).append(i).append(str3).append(i).append(str4).toString();
    }
}

第二組：

多次 For 回圈拼接一個字串，回圈結束后使用字串，使用后由垃圾回收器回收，也是分別使用 String 和 StringBuilder 拼接

/**
 * 多次回圈拼接成一個字串 用 String
 */
public static void useStringSpliceOneStr (){
    String str = "";
    for (int i = 0; i < CYCLE_NUM_LOWER; i++) {
        str += str1 + str2 + str3 + str4 + i;
    }
}

/**
 * 多次回圈拼接成一個字串 用 StringBuilder
 */
public static void useStringBuilderSpliceOneStr(){
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < CYCLE_NUM_LOWER; i++) {
        sb.append(str1).append(str2).append(str3).append(str4).append(i);
    }
}

為了保證測驗質量，在每個測驗專案進行前，執行緒休息 2s，之后空跑 5 次熱身，最后執行 5 次求平均時間的方式計算時間

public static int executeSometime(int kind, int num) throws InterruptedException {
    Thread.sleep(2000);
    int sum = 0;
    for (int i = 0; i < num + 5; i++) {
        long begin = System.currentTimeMillis();

        switch (kind){
            case 1:
                useString();
                break;
            case 2:
                useStringBuilder();
                break;
            case 3:
                useStringSpliceOneStr();
                break;
            case 4:
                useStringBuilderSpliceOneStr();
                break;
            default:
                return 0;
        }

        long end = System.currentTimeMillis();

        if(i > 5){
            sum += (end - begin);
        }
    }
    return sum / num;
}

主方法

public class StringTest {
    public static final int CYCLE_NUM_BIGGER = 10_000_000;
    public static final int CYCLE_NUM_LOWER = 10_000;
    public static final String str1 = "張三";
    public static final String str2 = "李四";
    public static final String str3 = "王五";
    public static final String str4 = "趙六";

    public static void main(String[] args) throws InterruptedException {
        int time = 0;
        int num = 5;

        time = executeSometime(1, num);
        System.out.println("String拼接 "+ CYCLE_NUM_BIGGER +" 次，" + num + "次平均時間：" + time + " ms");

        time = executeSometime(2, num);
        System.out.println("StringBuilder拼接 "+ CYCLE_NUM_BIGGER +" 次，" + num + "次平均時間：" + time + " ms");

        time = executeSometime(3, num);
        System.out.println("String拼接單個字串 "+ CYCLE_NUM_LOWER +" 次，" + num + "次平均時間：" + time + " ms");

        time = executeSometime(4, num);
        System.out.println("StringBuilder拼接單個字串 "+ CYCLE_NUM_LOWER +" 次，" + num + "次平均時間：" + time + " ms");

    }
}

測驗結果

測驗結果如下

結果分析

第一組

10_000_000 次回圈拼接，在回圈內使用 String 和 StringBuilder 的效率是一樣的！為什么呢？

使用 javap -c StringTest.class 反編譯查看兩個方法編譯后的檔案：

可以發現 String 方法拼接字串編譯器優化后使用的就是 StringBuilder、因此用例1 和用例2 的效率是一樣的，

第二組

第二組的結果就是大家喜聞樂見的了，由于 10_000_000 次回圈String 拼接實在太慢所以我采用了 10_000 次拼接來分析，

分析用例3：雖然編譯器會對 String 拼接做優化，但是它每次在回圈內創建 StringBuilder 物件，在回圈內銷毀，下次回圈他有創建，相比較用例4在回圈外創建，多了 n 次 new 物件、銷毀物件的操作、n - 1 次將 StringBuilder 轉換成 String 的操作，效率低也是理所應當了，

擴展

第一組的測驗還有一種寫法：

/**
 * 回圈內 使用 StringBuilder 拼接字串，一次回圈后銷毀
 */
public static void useStringBuilderOut(){
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < CYCLE_NUM_BIGGER; i++) {
//            sb.setLength(0);
        sb.delete(0, sb.length());
        String s = sb.append(str1).append(i).append(str2).append(i).append(str3).append(i).append(str4).toString();
    }
}

回圈外創建 StringBuilder 每次回圈開始的時候清空 StringBuilder 的內容然后拼接，這種寫法無論使用 sb.setLength(0); 還是 sb.delete(0, sb.length()); 效率都比直接在回圈內使用 String / StringBuilder 慢，奈何才疏學淺我一直想不明白為什么他慢，我猜測是 new 物件的速度比重置長度慢，于是這樣測驗了以下：

public static void createStringBuider() {
    for (int i = 0; i < CYCLE_NUM_BIGGER; i++) {
        StringBuilder sb = new StringBuilder();
    }
}

public static void cleanStringBuider() {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < CYCLE_NUM_BIGGER; i++) {
        sb.delete(0, sb.length());
    }
}

但是結果是 cleanStringBuider 更快，讓我摸不著頭腦

如果有大神看到希望可以幫忙分析分析

結論

編譯器會將 String 拼接優化成使用 StringBuilder，但是還是有一些缺陷的，主要體現在回圈內使用字串拼接，編譯器不會創建單個 StringBuilder 以復用
對于多次回圈內拼接一個字串的需求：StringBuilder 很快，因為其避免了 n 次 new 物件、銷毀物件的操作，n - 1 次將 StringBuilder 轉換成 String 的操作
StringBuilder 拼接不適用于回圈內每次拼接即用的操作方式，因為編譯器優化后的 String 拼接也是使用 StringBuilder 兩者的效率一樣，后者寫起來還方便...

近期熱文推薦：

1.1,000+ 道 Java面試題及答案整理(2021最新版)

2.別在再滿屏的 if/ else 了，試試策略模式，真香！！

3.臥槽！Java 中的 xx ≠ null 是什么新語法？

4.Spring Boot 2.5 重磅發布，黑暗模式太炸了！

5.《Java開發手冊（嵩山版）》最新發布，速速下載！

覺得不錯，別忘了隨手點贊+轉發哦！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/341675.html

標籤：Java

上一篇：Maven還停留在導jar包？快來探索Nexus私服的新世界

下一篇：activiti 獲取當前任務流程圖片的輸入流