ToB企服应用市场:ToB评测及商务社交产业平台

标题: 为什么 IDEA 建议去掉 StringBuilder，而要使用 “+” 拼接字符串？ [打印本页]
作者: 悠扬随风    时间: 2024-1-13 09:59
标题: 为什么 IDEA 建议去掉 StringBuilder，而要使用 “+” 拼接字符串？
作者：京东零售 姜波
来源：京东云开发者社区
各位小伙伴在字符串拼接时应该都见过下面这种提示：

内容翻译：报告StringBuffer、StringBuilder或StringJoiner的任何用法，这些用法可以用单个java.lang.String串联来替换。使用字符串串联可以使代码更短、更简单。只有当得到的串联至少与原始代码一样高效或更高效时，此检查才会报告。
大家普遍认知中，字符串拼接要用 StringBuilder，那为什么 idea 会建议你是用“+”呢，那到底 StringBuilder  和 “+”有什么具体区别呢，我们一起来探究一下。
推荐一个开源免费的 Spring Boot 实战项目：
https://github.com/javastacks/spring-boot-best-practice
1、普通拼接

普通的几个字符串拼接成一个字符串，直接使用“+” 因为教材等原因，当前依旧有许多人拼接字符串时认为使用“+”耗性能，首选StringBuilder。
实际上，从JDK5开始，Java编译器就做了优化，使用“+”拼接字符串，编译器编译后实际就自动优化为使用StringBuilder。
新建测试类StringTest，分别创建使用“+”拼接字符串和使用StringBuilder拼接字符串的方法；并新增Junit测试用例，分别调用拼接字符串100000次（这里不是循环拼接，而是执行多次拼接，因为一次拼接耗时太少，看不出差异），打印耗时。
  1. /**
  2. * 使用+拼接字符串
  3. */
  4. public String concatenationStringByPlus(String prefix, int i) {
  5.     return prefix + "-" + i;
  6. }
  8. /**
  9. * 使用StringBuilder拼接字符串
  10. */
  11. public String concatenationStringByStringBuilder(String prefix, int i) {
  12.     return new StringBuilder().append(prefix).append("-").append(i).toString();
  13. }
  15. /**
  16. * 测试使用+拼接字符串耗时
  17. */
  18. @Test
  19. public void testStringConcatenation01ByPlus() {
  20.     long startTime = System.currentTimeMillis();
  21.     int count = 100000;
  22.     for (int i = 0; i < count; i++) {
  23.         String str = concatenationStringByPlus("testStringConcatenation01ByStringBuilder:", i);
  24.     }
  25.     long endTime = System.currentTimeMillis();
  26.     System.out.println("testStringConcatenation01ByPlus，拼接字符串" + count + "次，花费" + (endTime - startTime) + "秒");
  27. }
  29. /**
  30. * 测试使用StringBuilder拼接字符串耗时
  31. */
  32. @Test
  33. public void testStringConcatenation02ByStringBuilder() {
  34.     long startTime = System.currentTimeMillis();
  35.     int count = 100000;
  36.     for (int i = 0; i < count; i++) {
  37.         String str = concatenationStringByStringBuilder("testStringConcatenation02ByStringBuilder:", i);
  38.     }
  39.     long endTime = System.currentTimeMillis();
  40.     System.out.println("testStringConcatenation02ByStringBuilder，拼接字符串" + count + "次，花费" + (endTime - startTime) + "秒");
  41. }
复制代码
执行Junit用例，看耗时统计输出：
  1. testStringConcatenation01ByPlus，拼接字符串100000次，花费33秒
  2. testStringConcatenation02ByStringBuilder，拼接字符串100000次，花费36秒
复制代码
虽然有差异，但是差异极小，考虑到执行了100000次，每次耗时的差异就更小了，而且程序执行有各种因素影响执行效率，可以认为耗时差不多。也可以多次执行对比耗时差异，也可以发现基本一致。
到class文件所在目录，执行 javap -c StringTest.class，对class文件进行反编译，查看编译后的代码差异。这里不要使用Intellij idea和JD进行反编译，因为反编译有优化，会都反编译成“+”拼接的，看不出来编译后的真正情况。

从图上可以看出两种拼接方法反编译后完全一样，没有差异，执行效率自然也是一样的。
既然执行效率一样，从代码简洁利于阅读考虑，推荐使用“+”拼接字符串。
2、循环拼接

循环拼接一个长字符串，建议使用StringBuilder，虽然“+”拼接字符串编译后也会变成StringBuilder，但是每次循环处理都会new一个StringBuilder对象，耗时会大大增加。而直接使用StringBuilder，new一次就可以了，效率相对高。
新增2个Junit测试用例，循环拼接10000次拼接一个字符串（次数少于上面的用例，因为拼接的是一个字符串，如果拼接次数太多，可能引发内存溢出）：
  1. /**
  2. * 循环使用+拼接字符串
  3. */
  4. @Test
  5. public void testLoopStringConcatenation03ByPlus() {
  6.     long startTime = System.currentTimeMillis();
  7.     int count = 10000;
  8.     String str = "testLoopStringConcatenation03ByPlus:";
  9.     for (int i = 0; i < count; i++) {
  10.         str = str + "-" + i;
  11.     }
  12.     System.out.println(str);
  13.     long endTime = System.currentTimeMillis();
  14.     System.out.println("testLoopStringConcatenation03ByPlus，拼接字符串" + count + "次，花费" + (endTime - startTime) + "秒");
  15. }
  17. /**
  18. * 测试循环使用StringBuilder拼接字符串耗时
  19. */
  20. @Test
  21. public void testLoopStringConcatenation04ByStringBuilder() {
  22.     long startTime = System.currentTimeMillis();
  23.     int count = 100000;
  24.     StringBuilder stringBuilder = new StringBuilder("testLoopStringConcatenation04ByStringBuilder:");
  25.     for (int i = 0; i < count; i++) {
  26.         stringBuilder.append("-");
  27.         stringBuilder.append(i);
  28.     }
  29.     String str = stringBuilder.toString();
  30.     System.out.println(str);
  31.     long endTime = System.currentTimeMillis();
  32.     System.out.println("testLoopStringConcatenation04ByStringBuilder，拼接字符串" + count + "次，花费" + (endTime - startTime) + "秒");
  33. }
复制代码
执行Junit用例，看耗时统计输出：
  1. testLoopStringConcatenation03ByPlus，拼接字符串10000次，花费463秒
  2. testLoopStringConcatenation04ByStringBuilder，拼接字符串10000次，花费13秒
复制代码
可以看出，差异明显，不在一个量级了。
总结

近期热文推荐：
1.1,000+ 道 Java面试题及答案整理(2022最新版)
2.劲爆！Java 协程要来了。。。
3.Spring Boot 2.x 教程，太全了！
4.别再写满屏的爆爆爆炸类了，试试装饰器模式，这才是优雅的方式！！
5.《Java开发手册（嵩山版）》最新发布，速速下载！
觉得不错，别忘了随手点赞+转发哦！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4