为什么IDEA建议去掉StringBuilder，而要使用“+”拼接字符串

青旅半醒 2024-02-05 18:44 62阅读 0赞

在字符串拼接时应该都见过下面这种提示：

![在这里插入图片描述][5253390cf7f14ad79e8e295879fc61c7.png_pic_center]

大家普遍认知中，字符串拼接要用`StringBuilder`，那为什么`idea`会建议你是用`+`呢，那到底`StringBuilder`和`+`有什么具体区别呢，我们一起来探究一下。

### 普通拼接 ###

普通的几个字符串拼接成一个字符串，直接使用`+`因为教材等原因，当前依旧有许多人拼接字符串时认为使用`+`耗性能，首选`StringBuilder`。

实际上，从`JDK5`开始，`Java`编译器就做了优化，使用`+`拼接字符串，编译器编译后实际就自动优化为使用`StringBuilder`。

新建测试类，分别创建使用`+`拼接字符串和使用`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`用例，看耗时统计输出：

![在这里插入图片描述][96d102e5344d4fe0a807a6115c9ec6c6.png_pic_center]

![在这里插入图片描述][32b0ddb766b342c09f1759220f195d7e.png_pic_center]

虽然有差异，但是差异极小，考虑到执行了100000次，每次耗时的差异就更小了，而且程序执行有各种因素影响执行效率，可以认为耗时差不多。也可以多次执行对比耗时差异，也可以发现基本一致。

到`class`文件所在目录，执行 `javap -c StringTest.class`，对class文件进行反编译，查看编译后的代码差异。这里不要进行反编译，因为反编译有优化，会都反编译成`+`拼接的，看不出来编译后的真正情况。

![在这里插入图片描述][c2dead259b4345a3b35405979d78ce42.png_pic_center]

从图上可以看出两种拼接方法反编译后完全一样，没有差异，执行效率自然也是一样的。

既然执行效率一样，从代码简洁利于阅读考虑，推荐使用`+`拼接字符串。

### 循环拼接 ###

循环拼接一个长字符串，建议使用`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`用例，看耗时统计输出：

![在这里插入图片描述][892d46c44dfd4432a45cec8667805802.png_pic_center]

![在这里插入图片描述][0d67f23708534e4894bf265701097987.png_pic_center]

可以看出，差异明显，不在一个量级了。

### 总结 ###

*  单纯的字符串拼接使用`+`，更快更简洁。
 *  循环拼接时使用`+`拼接字符串效率较低，推荐使用`StringBuilder`。

[5253390cf7f14ad79e8e295879fc61c7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/c7360bbb25904498a4a1c7839e0db409.png
[96d102e5344d4fe0a807a6115c9ec6c6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/ee83a3734e4d4db1bb27c393138330d1.png
[32b0ddb766b342c09f1759220f195d7e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/8e58c39f9e76429ea08a32b5eba5d8b5.png
[c2dead259b4345a3b35405979d78ce42.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/2a5c1694804d42789833408172cc2022.png
[892d46c44dfd4432a45cec8667805802.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/b482b67493a1437381cdc93a2a6fe264.png
[0d67f23708534e4894bf265701097987.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/ba38a4455bdc4a4ba8aa38eeb908711b.png