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

心已赠人 2023-06-29 02:22 28阅读 0赞

**目录**

1、普通的几个字符串拼接成一个字符串，直接使用“+”

2、循环拼接一个字符串，使用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进行反编译，因为反编译有优化，会都反编译成“+”拼接的，看不出来编译后的真正情况。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FPQk81MTY_size_16_color_FFFFFF_t_70][]

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

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

# 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拼接字符串。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FPQk81MTY_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200109213701865.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FPQk81MTY=,size_16,color_FFFFFF,t_70