java中，StringBuilder和StringBuff_阿里巴巴笔试题

.牛妹

对String的修改其实是new了一个StringBuilder并调用append方法，然后调用toString返回一个新的String。

StringBuffer是在StringBuilder基础上加锁，加锁是一个重量级的操作，需要调用操作系统内核来实现，比较耗时。

因此效率明显有：String<StringBuffer<StringBuilder;

但是这个并不是绝对的，因为JVM会对String进行优化，譬如

String str = "i"+"love"+"java";

其中的字符串在编译时就能确认，编译器会直接将其拼接成一个字符串放在常量池："i love java"；

但是若是String a = "i"; String b = "love"; String c = "java";

String str = a+b+c;

只有运行时才能确认str最终是什么，编译器并不会进行优化，是通过StringBuilder实现的。

发表于 2017-07-08 16:13:15 回复(8)

菩提旭光

效率：StringString(大姐，出生于JDK1.0时代) 不可变字符序列 <StringBuffer(二姐，出生于JDK1.0时代) 线程安全的可变字符序列 <StringBuilder(小妹，出生于JDK1.5时代) 非线程安全的可变字符序列。Java中的String是一个类，而并非基本数据类型。string是值传入，不是引用传入。 StringBuffer和StringBuilder可以算是双胞胎了，这两者的方法没有很大区别。但在线程安全性方面，StringBuffer允许多线程进行字符操作。这是因为在源代码中StringBuffer的很多方法都被关键字 synchronized 修饰了，而StringBuilder没有。 StringBuilder的效率比StringBuffer稍高，如果不考虑线程安全，StringBuilder应该是首选。另外，JVM运行程序主要的时间耗费是在创建对象和回收对象上。

发表于 2015-08-16 13:31:12 回复(12)

MyGoodHelper

C

String对String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，而不是StringBuffer；StringBuffer每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。

发表于 2015-01-05 12:44:29 回复(9)

大河儿马

String S1 = “This is only a” + “ simple” + “ test” ;

在编译的时候S1就是常量了可以理解为 String S1 = “This is only a simple test” ; ，不存在运行时对字符串的处理，所以效率最高。

发表于 2015-09-19 21:40:00 回复(7)

蓄意碎碎

String S1 = “This is only a” + “ simple” + “ test”时，String效率最高。

是因为，“this si only a ” 和 "simple " " test" 都是常量，所以效率高

而如果 String S1 = S2 + S3 + S4 ;

那么效率就低了，得多生成一些对象...

发表于 2015-08-31 11:47:28 回复(1)

zhuyueming

单线程运行效率： String<< StringBuffer< StringBuilder

非线程安全：StringBuilder

线程安全：StringBuffer

单线程最佳：StringBuilder

发表于 2016-05-19 18:47:58 回复(0)

李滔

C错,题目描述的应该是String类型不是StringBuffer.

D是对的,Jvm会自动优化成String s1 = “This is only a simple test”,如果是String s1 = “This is only a”;

String s2 = “ simple”;

String s3 = “ test”;

String s = s1+s2+s3;则String的效率最慢

当String、StringBuffer、StringBuilder，从0拼接到100000所花费的时间如下：

总结：

StringBuiler>StringBuffer>String

发表于 2017-07-27 15:00:08 回复(0)

何时明月

StringBuilder 是非线程安全的，String会生成新的对象，stringbuffer 对于字符串的操作都是对原字符串的改变

发表于 2016-04-11 19:31:42 回复(0)

七。小H

解析： String：字符串常量

StringBuffer：字符串变量，是线程安全的

StringBuilder：字符串变量，非线程安全的

1 String s = "abcd";
2 s = s+e;
3 System.out.print(s);// result : abcde

这里的结果虽然变成了abcde,但是此时的s已经不再是第一行中的s，因为String是常量，所以对于第二行的代码，虚拟机会重新生成一个新的对象s，并且清楚原先的对象s。

都知道的是StringBuffer是线程安全的，stringBuilder是非线程安全的。并且有上述可知，String的效率是非常慢的。所以从执行效率上来看String<StringBuffer<StringBuilder.

StringBuffer对String类型转换的时候，是用的append（）方法，这种方法并不是创建一个新的String对象，所以C是错的。

发表于 2015-10-21 22:53:47 回复(0)

以前没的选择现在只想拿offer

使用情况：

String操作少量数据。

StringBuffer在多线程下操作大量数据。

StringBuilder在单线程下操作大量数据。

这里应该算是少量数据，String效率会高。

发表于 2018-07-16 16:26:46 回复(0)

梅老板的粉

c++走错片场，飘过。。

发表于 2017-06-21 10:54:24 回复(0)

bealikeflower

String 字符串常量 StringBuffer 字符串变量（线程安全） StringBuilder 字符串变量（非线程安全）简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的： String S1 = “This is only a” + “ simple” + “ test”; StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”); 你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个 String S1 = “This is only a” + “ simple” + “test”; 其实就是： String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如： String S2 = “This is only a”; String S3 = “ simple”; String S4 = “ test”; String S1 = S2 +S3 + S4; 这时候 JVM 会规规矩矩的按照原来的方式去做在大部分情况下 StringBuffer > String StringBuffer Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。 StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。在大部分情况下 StringBuilder > StringBuffer java.lang.StringBuilde java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

发表于 2017-06-08 18:28:22 回复(0)

kmust_XiaQing

C.

String表示字符串，它是一个常量，也就是说当我们对一个String变量进行赋值时（String a ="hello"， a = “helloworld”），首先在字符串常量池中找有没有hello，没有，那么开辟一个空间存储hello，再把helloworld赋值给a时，字符串常量池中并没有helloworld,所以再开辟一个空间存储helloworld，并把a指向这个helloworld。

StringBuilder和StringBuffer是字符串缓冲区对象，它们可以改变值，也就是说，StringBuilder a = new StringBuilder();a.append("hello");向a中追加字符串hello,a.append("world"),再向a中追加字符，a中的值是可以变化的。它并没有产生一个新的对象，所以C答案错误。

StringBuffer和StringBuilder的区别是StringBuffer线程安全，效率低；StringBuilder线程不安全，效率高

发表于 2015-08-18 16:07:06 回复(0)

宋佑廉

D选项,因为常量的相加在编译的时候已经编译好了,可以通过反编译的手段进行查看

反编译的时候等同于String S1 = “This is only a simple test

发表于 2018-10-31 23:48:57 回复(0)

LSur

String家族三兄弟

对String的修改其实是new了一个StringBuilder并调用append方法，然后调用toString返回一个新的String。

StringBuffer是在StringBuilder基础上加锁，加锁是一个重量级的操作，需要调用操作系统内核来实现，比较耗时。

因此效率明显有：String<StringBuffer<StringBuilder;

但是这个并不是绝对的，因为JVM会对String进行优化，譬如

String str = "i"+"love"+"java";

其中的字符串在编译时就能确认，编译器会直接将其拼接成一个字符串放在常量池："i love java"；

但是若是String a = "i"; String b = "love"; String c = "java";

String str = a+b+c;

只有运行时才能确认str最终是什么，编译器并不会进行优化，是通过StringBuilder实现的。

所以效率比较String<StringBuffer<StringBuilder，但是在 String S1 = “This is only a” + “ simple” + “ test”时，String效率最高。

***********************************************补充***************************************************
StringBuffer和StringBuilder是对自身进行操作，不new一个新对象。

而Stringy由于是final修饰，不可变。则必须重新new一个String对象作为结果，再把指针指向新的String。

查看一下String的源码，可知字符串的连接操作分两种情况：

1.当连接的字符串为变量即为a+b+c时，则对String的修改其实是new了一个StringBuilder（或者StringBuffer）并调用append方法，然后调用toString返回一个新的String。此时String的效率最慢。

2.当连接的字符串为常量即为'a'+'b'+'c'时，则调用String的concat和getChars方法(将此字符串的字符复制到目标字符数组中)，这个时候并没有创建StringBuffer和StringBuilder对象。详情见下图，此时String的效率最块。

编辑于 2018-07-05 21:24:50 回复(0)

林小七七

1.String：字符串常量，字符长度不可变

2.StringBuffer（JDK1.0）：（synchronize线程安全）字符串变量

Java.lang.StringBuffer线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。

主要操作有append和insert方法

3.StringBuilder（JDK5.0）：（非线程安全）字符串常量

是JDK5.0新增的。此类提供一个与StringBuffer兼容的API，但不保证同步。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。

效率： String<StringBuffer<StringBuilder

发表于 2018-06-03 21:45:47 回复(0)

程序猿的程

StringBuffer是可变类，每次操作都是对其本身对象进行操作。StringBuffer这个类的一个最大特点就是减少jvm创建String对象的次数。

发表于 2017-04-23 21:52:50 回复(0)

思考_行动

AB
效率：StringString(大姐，出生于JDK1.0时代) 不可变字符序列 <StringBuffer(二姐，出生于JDK1.0时代) 线程安全的可变字符序列 <StringBuilder(小妹，出生于JDK1.5时代) 非线程安全的可变字符序列
C

String对String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后引用为新的 String 对象，而不是StringBuffer；StringBuffer每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。
D
String S1 = “This is only a” + “ simple” + “ test” ;

在编译的时候S1就是常量了可以理解为 String S1 = “This is only a simple test” ; ，不存在运行时对字符串的处理，所以效率最高。

编辑于 2017-04-21 19:43:25 回复(0)

劳建成

答案应该是D C中StringBuffer添加字符串时（调用append()方法），需要扩展数组（调用AbstractStringBuilder的expandCapacity()方法），里面调用了Arrays.copyOf()方法，此方法再调用System.arraycopy()方法，实际上就是给StringBuffer的字符串数组value重新分配一个新的对象，所以C是对的 D中效率从高到低排序：String > StringBuilder > StringBuffer，因为StringBuffer线程安全，所以效率低

发表于 2016-11-04 10:43:21 回复(0)

小新没有蜡笔~

StringBuffer 每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。

发表于 2016-07-12 10:23:43 回复(0)

java中，StringBuilder和StringBuff

String家族三兄弟

问题信息

热门推荐

相关试题