“+”运算符进行字符串连接和 StringBuffer/StringBuilder对象的 append 方法连接字符串的区别？

最新推荐文章于 2022-02-17 16:02:31 发布
最新推荐文章于 2022-02-17 16:02:31 发布
阅读量467 收藏
点赞数 1
分类专栏： 笔记 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50594210/article/details/114548878
版权

字符串是 Java 程序中最常用的数据结构之一 。在 Java 中 String 类已经重载了"+"。也就是说，字符串可以直接使用"+"进行连接，如下面代码所示：

String str = "abc" + "abc";

在 Java 中提供了一个StringBuilder 类，这个类也可以起到"+"的作用。那么这两种方法有什么区别呢？
看看如下的代码：

package string;

 public class Test
 {
  public static void main(String[] args)
		 {
 		String s1 = "abc";
 		String s2 = "hello" + s1 + "word" + 5;
 		System.out.println(s2);
		 }
 }

上面的代码将会输出正确的结果。从表面上看，对字符串和整型使用"+"号并没有什么区别。但是使用反编译工具将 Test 反编译成 Java Byte Code，结果就一目了然了。

本文使用的是 jad 来反编译，命令如下：jad -o -a -s d.java Test.class

反编译后的代码如下：

 package string;

 import java.io.PrintStream;

 public class Test
 {
 public Test()
 {
 // 0 0:aload_0
 // 1 1:invokespecial #8 <Method void Object()>
 // 2 4:return
 }

 public static void main(String args[])
 {
 String s1 = "abc";
 // 0 0:ldc1 #16 <String "abc">
 // 1 2:astore_1
 String s2 = (new StringBuilder("hello")).append(s1).append("word").append(5).toString();
 // 2 3:new #18 <Class StringBuilder>
 // 3 6:dup
 // 4 7:ldc1 #20 <String "hello">
 // 5 9:invokespecial #22 <Method void StringBuilder(String)>
 // 6 12:aload_1
 // 7 13:invokevirtual #25 <Method StringBuilder StringBuilder.append(String)>
 // 8 16:ldc1 #29 <String "word">
 // 9 18:invokevirtual #25 <Method StringBuilder StringBuilder.append(String)>
 // 10 21:iconst_5
 // 11 22:invokevirtual #31 <Method StringBuilder StringBuilder.append(int)>
 // 12 25:invokevirtual #34 <Method String StringBuilder.toString()>
 // 13 28:astore_2
 	System.out.println(s2);
 // 14 29:getstatic #38 <Field PrintStream System.out>
 // 15 32:aload_2
 // 16 33:invokevirtual #44 <Method void PrintStream.println(String)>
 // 17 36:return
 }
 }

从上面的代码很容易看出，虽然在源程序中使用了"+"，但在编译时仍然将"+"转换成 StringBuilder。因此，我们可以得出结论，在 Java 中无论使用何种方式进行字符串连接，实际上都使用的是 StringBuilder。

从运行结果来解释，那么"+“和 StringBuilder 是完全等效的。但如果从运行效率和资源消耗方面看，那它们将存在很大的区别。如果连接字符串行表达式很简单（如上面的顺序结构），那么”+"和 StringBuilder 基本是一样的，但如果结构比较复杂，如使用循环来连接字符串，那么产生的 Java Byte Code 就会有很大的区别。先让我们看看如下的代码：

 package string;
 
 import java.util.*;

 public class TestComplexPlus
 {
 		public static void main(String[] args)
 		{
 			String s = "";
 			Random rand = new Random();
 			for (int i = 0; i < 100; i++)
 		{
 			s = s + rand.nextInt(10000) + " ";
 		}
		 System.out.println(s);
 	}
 }

上面的代码返编译后的 Java Byte Code 如下：

 package string;

 import java.io.PrintStream;
 import java.util.Random;

 public class TestComplexPlus
 {

 public TestComplexPlus()
 {
 // 0 0:aload_0
 // 1 1:invokespecial #8 <Method void Object()>
 // 2 4:return
 }

 public static void main(String args[])
 {
 String s = "";
 // 0 0:ldc1 #16 <String "">
 // 1 2:astore_1
 Random rand = new Random();
 // 2 3:new #18 <Class Random>
 // 3 6:dup
 // 4 7:invokespecial #20 <Method void Random()>
 // 5 10:astore_2
 for(int i = 0; i < 100; i++)
 //* 6 11:iconst_0
 //* 7 12:istore_3
 //* 8 13:goto 49
 s = (new StringBuilder(String.valueOf(s))).append(rand.nextInt(10000)).append(" ").toString();
 // 9 16:new #21 <Class StringBuilder>
 // 10 19:dup
 // 11 20:aload_1
 // 12 21:invokestatic #23 <Method String String.valueOf(Object)>
 // 13 24:invokespecial #29 <Method void StringBuilder(String)>36. // 14 27:aload_2
 // 15 28:sipush 1000
 // 16 31:invokevirtual #32 <Method int Random.nextInt(int)>
 // 17 34:invokevirtual #36 <Method StringBuilder StringBuilder.append(int)>
 // 18 37:ldc1 #40 <String " ">
 // 19 39:invokevirtual #42 <Method StringBuilder StringBuilder.append(String)>
 // 20 42:invokevirtual #45 <Method String StringBuilder.toString()>
 // 21 45:astore_1

 // 22 46:iinc 3 1
 // 23 49:iload_3
 // 24 50:bipush 10
 // 25 52:icmplt 16
 System.out.println(s);
 // 26 55:getstatic #49 <Field PrintStream System.out>
 // 27 58:aload_1
 // 28 59:invokevirtual #55 <Method void PrintStream.println(String)>
// 29 62:return
 }
 }

可以看到，虽然编译器将"+"转换成了 StringBuilder，但创建 StringBuilder 对象的位置却在 for 语句内部。这就意味着每执行一次循环，就会创建一个StringBuilder 对象（对于本例来说，是创建了 100个 StringBuilder对象），虽然 Java 有垃圾回收器，但这个回收器的工作时间是不定的。如果不断产生这样的垃圾，那么仍然会占用大量的资源。解决这个问题的方法就是在程序中直接使用 StringBuilder 来连接字符串，代码如下：

 package string;

 import java.util.*;

 public class TestStringBuilder
 {
		 public static void main(String[] args)
 		{
		String s = "";
		 Random rand = new Random();
 	 StringBuilder result = new StringBuilder();
 	 for (int i = 0; i < 100; i++)
 	 {
 		result.append(rand.nextInt(10000));
 	 result.append(" ");}
 		System.out.println(result.toString());
 	}
 }

上面代码反编译后的结果如下：

package string;

 import java.io.PrintStream;
 import java.util.Random;

 public class TestStringBuilder
 {

 public TestStringBuilder()
 {
 // 0 0:aload_0
 // 1 1:invokespecial #8 <Method void Object()>
 // 2 4:return
 }

 public static void main(String args[])
 {
 String s = "";
 // 0 0:ldc1 #16 <String "">
 // 1 2:astore_1
 Random rand = new Random();
 // 2 3:new #18 <Class Random>
 // 3 6:dup
 // 4 7:invokespecial #20 <Method void Random()>
 // 5 10:astore_2
 StringBuilder result = new StringBuilder();
 // 6 11:new #21 <Class StringBuilder>
 // 7 14:dup
 // 8 15:invokespecial #23 <Method void StringBuilder()>
 // 9 18:astore_3
 for(int i = 0; i < 10; i++)
 //* 10 19:iconst_0
 //* 11 20:istore 4
 //* 12 22:goto 47
 {
 result.append(rand.nextInt(1000));// 13 25:aload_3
 // 14 26:aload_2
 // 15 27:sipush 1000
 // 16 30:invokevirtual #24 <Method int Random.nextInt(int)>
 // 17 33:invokevirtual #28 <Method StringBuilder StringBuilder.append(int)>
 // 18 36:pop
 result.append(" ");
 // 19 37:aload_3
 // 20 38:ldc1 #32 <String " ">
 // 21 40:invokevirtual #34 <Method StringBuilder StringBuilder.append(String)>
 // 22 43:pop
 }

 // 23 44:iinc 4 1
 // 24 47:iload 4
 // 25 49:bipush 10
 // 26 51:icmplt 25
 System.out.println(result.toString());
 // 27 54:getstatic #37 <Field PrintStream System.out>
 // 28 57:aload_3
 // 29 58:invokevirtual #43 <Method String StringBuilder.toString()>
 // 30 61:invokevirtual #47 <Method void PrintStream.println(String)>
 // 31 64:return
 }
 }

从上面的反编译结果可以看出，创建 StringBuilder 的代码被放在了 for语句外虽然这样处理在源程序中看起来复杂，但却换来了更高的效率，同时消耗的资源也更少了。

在使用 StringBuilder 时要注意，尽量不要"+"和 StringBuilder 混着用，否则会创建更多的 StringBuilder 对象，如下面代码：

for (int i = 0; i < 100; i++)
{
	result.append(rand.nextInt(10000));
	result.append(" ");
}

改成如下形式：

for (int i = 0; i < 100; i++)
{
	result.append(rand.nextInt(10000) + " ");
}

则反编译后的结果如下：

for(int i = 0; i < 100; i++)
//* 10 19:iconst_0
//* 11 20:istore 4
//* 12 22:goto 65
{
result.append((new StringBuilder(String.valueOf(rand.nextInt(10000)))).append(" ").toString());
// 13 25:aload_3
// 14 26:new #21 <Class StringBuilder>
// 15 29:dup

从上面的代码可以看出，Java 编译器将"+"编译成了 StringBuilder，这样 for 语句每循环一次，又创建了一个StringBuilder 对象。

如果将上面的代码在 JDK1.4 下编译，必须将 StringBuilder 改为 StringBuffer，而 JDK1.4 将"+"转换为StringBuffer（因为 JDK1.4 并没有提供 StringBuilder 类）。StringBuffer 和 StringBuilder 的功能基本一样，只是StringBuffer 是线程安全的，而 StringBuilder 不是线程安全的。因此，StringBuilder 的效率会更高。

改变世界的李
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
简单的讲一下String，StringBuilder和StringBuffer的区别
weixin_43786099的博客
08-27 1万+
String、StringBuilder和StringBuffer的区别 String类： String是一个长度不可变的字符序列，底层是一个被final修饰的char[]数组，所以说，任何对 String 类型进行改变的操作实际上都是重新生成了一个新的String对象，然后将指针指向新的 String 对象，这样不仅效率低下，而且大量浪费有限的内存空间，所以经常改变内容的字符串最好不要用 String 。 上图中，首先执行了一个String s = “JAVA” 对象，对象s入栈，对应的堆中生成了...
StringBuffer和StringBuilder的区别
热门推荐
其实并不难,是你太悲观
05-20 26万+
无论是做Java或是Android，都避免不了遇到这个问题，其实kai
StringBuffer与StringBuilder的区别
m0_46331585的博客
09-28 2万+
StringBuffer与StringBuilder的区别 一、String,StringBuffer与StringBuilder String字符串常量 String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，这样不仅效率低下，而且大量浪费有限的内存空间。 StringBuffer与StringBuilder是字符串变量 StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象 二、StringBuf
加号和stringbuffer.append()的区别
u014344668的专栏
10-10 773
String中三种加法的区别 JAVA的确是一种令程序员陷入两难境地的言语, 确切的说是思想. 它提供了如此丰富的library,让程序员能够很容易的写出功能强大的程序. 同时它也封装了如此多的细节, 让程序员能够轻易的写出很拙略的程序. 它所代表的object指向思想设计之初是为了把程序员从纷繁复杂的编程细节中解放出来,来达到对已有程序的利用. 但是在编程 实际上又要求程序员了解其实现的细节而...
java 字符串连接（+、concat、StringBuffer/StringBuilder）效率比对
szw-yunie的博客
07-04 1331
三种方法 java字符串连接有三种方法： 用加号+连接，如："abc"+"bcd" String对象的concat方法，如："abc".concat("bcd") 以及StringBuffer或StringBuilder类，如： StringBuilder stringBuilder = new StringBuilder ("abc"); stringBuilder.append ("bcd"); stringBuilder.toString (); StringBuffer和StringB
javascript之大字符串的连接的StringBuffer 类
10-30
传统的字符串连接方式，如使用`+`或`+=`运算符，随着字符串长度的增长，性能会显著下降，因为每次操作都会创建新的字符串对象。为了解决这个问题，我们可以借鉴Java中的`StringBuffer`或`StringBuilder`类的概念，...
产品总和：＃使用数学运算符和字符串连接的Java实践
02-20
2. StringBuilder和StringBuffer：当需要频繁地对字符串进行拼接时，使用StringBuilder或StringBuffer（线程安全）类更高效，因为它们可以在内部重用存储空间，避免了每次连接时创建新的字符串对象。 ```java ...
Java 中 String，StringBuffer 和 StringBuilder 的区别及用法
08-31
Java 中 String、StringBuffer 和 StringBuilder 是三个常用的字符串操作类，了解它们之间的区别对 Java 开发者来说非常重要。本文将详细介绍这三者的区别、用法及各自的优缺点。 String String 是 Java 中最基本...
Java 实例 - 两种连接字符串方法的性能比较源代码-详细教程.zip
最新发布
08-07
在本教程的源代码中，你将找到这样的比较实验，它们创建了大量字符串并进行连接，对比`StringBuffer` 和 `StringBuilder` 的性能差异。实验结果通常显示，在单线程环境下，`StringBuilder` 的性能优于`StringBuffer`...
java通用字符串连接
12-17
首先，字符串连接在Java中最基本的方式是使用`+`运算符或者`StringBuilder`或`StringBuffer`类。然而，当涉及到集合时，手动迭代并连接每个元素会变得繁琐且效率低下。为了提高效率和代码的可读性，可以编写一个通用...
String StringBuffer和StringBuilder区别之源码解析
12-07
String StringBuffer和StringBuilder 区别之源码解析 从源码角度简单对它们之间的区别进行了验证
在Java中连接字符串时是使用+号还是使用StringBuilder
我的新blog：<http://nokiaguy.blogjava.net> <http://nokiaguy.cnblogs.com>
06-18 9631
    字符串是Java程序中最常用的一种数据结构之一。在Java中的String类已经重载了"+"。也就是说，字符串可以直接使用"+"进行连接，如下面代码所示：String s = "abc" + "ddd";但这样做真的好吗？当然，这个问题不能简单地回答yes or no。要根据具体情况来定。在Java中提供了一个StringBuilder类（这个类只在J2SE5及以上版本
java中String字符串拼接“+”和StringBuffer的效率对比
会飞的鱼儿的博客
10-23 4189
1、前言 （1）最近在做数据传输时，由于接收的数据量较大，在字符串拼接时使用了以前感觉方便的“+”进行字符串拼接，最后拼接到最后时间越来越多，导致效率变慢。 2、String拼接 首先来看一下两个String用“+”号拼接需要的时间 String aa="E0 00 00 00 00 06 10 FF F1 45 11 00 4F 16 12 00 1E 0A 13 00 0B 4E 1...
StringBuilder 和 StringBuffer 区别
qq_32703711的博客
10-12 4451
之前只知道StringBuilder是线程不安全的，StringBuffer是线程安全的。但是核心细节都记不清楚，学习一下。 先上两个类的示意图 StringBuilder： StringBuffer： 区别1：StringBuffer 线程安全，StringBuilder 不安全： a. StringBuffer 使用 synchronized 修饰，使其线程安全。下图是StringBuffer的代码。 b. StringBuilder代码 区别2. 性能...
2020-02-26
圈圈的博客
02-26 280
** Java学习第三讲 ** •break及 continue后面可以跟一个语句标号。 •Java中不可以在任一表达式后面加分号构成表达式语句。 •循环一般有五个要素。 •数组都是引用类型。 •书写表达式要适量运用括号，非少用。 •case后面不可以跟变量。 •循环语句有三种写法。 •do.while循环至少执行一次。 •数组都有一个属性 length。 •声明数组时可以直接指定数组的大小。 •...
【String、StringBuffer与StringBuilder区别】
qq_36348243的博客
02-17 248
String、StringBuffer与StringBuilder区别StringStringBuffer与StringBuilder做个小笔记使用场景小结 String 字符串广泛应用 在Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。 String表示字符串。字符串是常量，它们的值在创建后无法更改。因为 String 对象是不可变的，所以它们可以被共享，是线程安全的。 由于String的值是不可变的，这就导致每次对String的操作都会生成新的St
StringBuffer与StringBuilder之间的区别
怀揣梦想，努力前行
03-02 7609
public class Test { public static void main(String[] args) { StringBuffer strBuffer = new StringBuffer(); strBuffer.append("StringBuffer"); strBuffer.append(" "); strBuffer.append("Test"
Java中字符串连接符(+)和append的区别
weixin_30445169的博客
10-15 957
参考链接：https://www.jianshu.com/p/849f1d443b3a 文章结构： 　　第一部分：对+的原理进行分析 　　第二部分：+ 和 append 循环对比（贴出代码，以及分别循环后的反编译字节码，来对两者进行对比） 一： + 底层原理解析（+ 的底层是new StringBuilder 进行append） 1 String str1 = "hello"; 2...
什么情况下用+运算符进行字符串连接比调用stringbuffer/stringbuilder对象的append方法连接字符串性能更好？
03-16
在字符串连接较少的情况下，使用+运算符进行字符串连接比调用StringBuffer/StringBuilder对象的append方法连接字符串性能更好。因为在连接较少的情况下，JVM会对+运算符进行优化，将其转换为StringBuilder对象的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

改变世界的李

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值