黑马程序员技术交流社区

标题: JAVA基础 [打印本页]

作者: 碧血丹心 时间: 2015-12-10 22:41
标题: JAVA基础
String与StringBuilder的区别？（请全面具体分条陈述）

作者: a944090777 时间: 2015-12-10 22:50
String的内容不能更改，想更改引用的内容只能指向新地址；StringBuilder的内容能更改，这两个类的AP基本一致。顺便说一下，StringBuilder不是线程安全的！

作者: bbaijiajinger 时间: 2015-12-10 23:00
String与String与String与StringBuilder
String是不可变本质是一个char数组
StringBuilder底层是一个“可变数组”默认是十六个字节当向其中添加原素容量剩余不多就会新建一个更大的数组把原来数组中的内容复制到新数组中。

作者: 萧未然 时间: 2015-12-11 10:54
类似Writer和BufferedWriter，StringBuilder是String的装饰类，不过是对String提供了更多的功能，比如反转等。至于底层，建议楼主还是百度看看更全面些

作者: 1570881814 时间: 2015-12-11 12:46
String的内容不能更改，StringBuilder的内容能更改，

作者: zcbcba123 时间: 2015-12-11 18:07
http://blog.csdn.net/mad1989/article/details/26389541为什么自己不先查查呢...

作者: 13651804082 时间: 2015-12-11 18:23
面试时可以回答
String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。
StringBuffer是同步的，数据安全，效率低；StringBuilder是不同步的，数据不安全，效率高

作者: 林以 时间: 2015-12-11 22:48

String的内容不能更改，
StringBuilder的内容可以更改，这两个类的API基本一致。
而且StringBuilder提供了更丰富的字符串处理方法

作者: hard 时间: 2015-12-12 12:11
咱论坛里面有阳哥的Java基础里面介绍的很详细的

作者: VisionDo 时间: 2015-12-12 14:02
本帖最后由 VisionDo 于 2015-12-12 14:07 编辑

public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence
The String class represents character strings. All string literals in Java programs, such as "abc", are implemented as instances of this class.
Strings are constant; their values cannot be changed after they are created. String buffers support mutable strings. Because String objects are immutable they can be shared. For example:

   String str = "abc";

is equivalent to:

   char data[] = {'a', 'b', 'c'};
   String str = new String(data);

API：
公用不可修改类String继承自对象类，实现了可序列化，可比（与字符串可比），字符序列化
Java程序里的所有字符串常量，比如“abc”，都是该类的实例化。
字符串是常量。一旦被创建后，他们的值是不可改变的。字符串缓冲区支持可变字符串，因为字符串对象不可更改它们可以被共享。

<div class="quote"><blockquote>Class StringBuffer

java.lang.Object
java.lang.StringBuffer
All Implemented Interfaces:
Serializable, Appendable, CharSequence

public final class StringBuffer
extends Object
implements Serializable, CharSequence
A thread-safe, mutable sequence of characters. A string buffer is like a String, but can be modified. At any point in time it contains some particular sequence of characters, but the length and content of the sequence can be changed through certain method calls.
String buffers are safe for use by multiple threads. The methods are synchronized where necessary so that all the operations on any particular instance behave as if they occur in some serial order that is consistent with the order of the method calls made by each of the individual threads involved.

公用不可修改类StringBuffer继承自对象类，实现了可序列化，可追加，可字符序列化。
它是线程安全的可变字符序列。一个String Buffer就像一个字符串，但是，它可以被更改。在任意时间点，通过调用特定的方法，可以修改String Buffer中包含的特定字符串序列的内容和长度。
在多线程中使用String Buffer是安全的。在必要的情况下，对所有特定实例的操作都是同步的，比如每个命令的执行顺序是与那些调用他们的线程的顺序是一致的。

java.lang
Class StringBuilder

java.lang.Object
java.lang.StringBuilder
All Implemented Interfaces:
Serializable, Appendable, CharSequence

public final class StringBuilder
extends Object
implements Serializable, CharSequence
A mutable sequence of characters. This class provides an API compatible with StringBuffer, but with no guarantee of synchronization. This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread (as is generally the case). Where possible, it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations.

公用不可修改类StringBuffer继承自对象类，实现了可序列化，可追加，可字符序列化。
它是可变字符序列。该类提供了一个兼容StringBuffer的接口，但没有保证同步(个人理解为不可以在多线程中使用)。StringBuilder类被设计用来代替StringBuffer,当StringBuffer正在被被单线程使用的时候(在一般的情况)。如果可能的话，建议优先使用StringBuffer，因为StringBuffer更高效。

作者: 唐洪超 时间: 2015-12-12 20:46
String可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了存储数值不可改变的字符串。

作者: 唐洪超 时间: 2015-12-12 20:50

唐洪超发表于 2015-12-12 20:46
String可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了存储数值不可改变的字符串。 ...

StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用或者变量的内容不断变化，那么最好用StringBuffer。

作者: 衙门口，门朝南 时间: 2015-12-13 08:20
百度啊

作者: Steve_小海 时间: 2015-12-13 23:02
String、StringBuffer、StringBuilder区别
StringBuffer、StringBuilder和String一样，也用来代表字符串。String类是不可变类，任何对String的改变都会引发新的String对象的生成；StringBuffer则是可变类，任何对它所指代的字符串的改变都不会产生新的对象。既然可变和不可变都有了，为何还有一个StringBuilder呢？相信初期的你，在进行append时，一般都会选择StringBuffer吧！
先说一下集合的故事，HashTable是线程安全的，很多方法都是synchronized方法，而HashMap不是线程安全的，但其在单线程程序中的性能比HashTable要高。StringBuffer和StringBuilder类的区别也是如此，他们的原理和操作基本相同，区别在于StringBufferd支持并发操作，线性安全的，适合多线程中使用。StringBuilder不支持并发操作，线性不安全的，不适合多线程中使用。新引入的StringBuilder类不是线程安全的，但其在单线程中的性能比StringBuffer高。

StringBuffer常用方法
（由于StringBuffer和StringBuilder在使用上几乎一样，所以只写一个，以下部分内容网络各处收集，不再标注出处）
StringBuffer s = new StringBuffer();
这样初始化出的StringBuffer对象是一个空的对象，
StringBuffer sb1=new StringBuffer(512);
分配了长度512字节的字符缓冲区。
StringBuffer sb2=new StringBuffer(“how are you?”)
创建带有内容的StringBuffer对象，在字符缓冲区中存放字符串“how are you?”

a、append方法
public StringBuffer append(boolean b)
该方法的作用是追加内容到当前StringBuffer对象的末尾，类似于字符串的连接，调用该方法以后，StringBuffer对象的内容也发生改变，例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.append(true);
则对象sb的值将变成”abctrue”
使用该方法进行字符串的连接，将比String更加节约内容，经常应用于数据库SQL语句的连接。

b、deleteCharAt方法
public StringBuffer deleteCharAt(int index)
该方法的作用是删除指定位置的字符，然后将剩余的内容形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“KMing”);
sb. deleteCharAt(1);
该代码的作用删除字符串对象sb中索引值为1的字符，也就是删除第二个字符，剩余的内容组成一个新的字符串。所以对象sb的值变为”King”。
还存在一个功能类似的delete方法：
public StringBuffer delete(int start,int end)
该方法的作用是删除指定区间以内的所有字符，包含start，不包含end索引值的区间。例如：
StringBuffer sb = new StringBuffer(“TestString”);
sb. delete (1,4);
该代码的作用是删除索引值1(包括)到索引值4(不包括)之间的所有字符，剩余的字符形成新的字符串。则对象sb的值是”TString”。

c、insert方法
public StringBuffer insert(int offset, boolean b),
该方法的作用是在StringBuffer对象中插入内容，然后形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“TestString”);
sb.insert(4,false);
该示例代码的作用是在对象sb的索引值4的位置插入false值，形成新的字符串，则执行以后对象sb的值是”TestfalseString”。

d、reverse方法
public StringBuffer reverse()
该方法的作用是将StringBuffer对象中的内容反转，然后形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.reverse();
经过反转以后，对象sb中的内容将变为”cba”。

e、setCharAt方法
public void setCharAt(int index, char ch)该方法的作用是修改对象中索引值为index位置的字符为新的字符ch。例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.setCharAt(1,’D’);
则对象sb的值将变成”aDc”。

f、trimToSize方法
public void trimToSize()
该方法的作用是将StringBuffer对象的中存储空间缩小到和字符串长度一样的长度，减少空间的浪费，和String的trim()是一样的作用，不在举例。

g、length方法
该方法的作用是获取字符串长度，不用再说了吧。

h、setlength方法
该方法的作用是设置字符串缓冲区大小。
StringBuffer sb=new StringBuffer();
sb.setlength(100);
如果用小于当前字符串长度的值调用setlength()方法，则新长度后面的字符将丢失。

i、sb.capacity方法
该方法的作用是获取字符串的容量。
StringBuffer sb=new StringBuffer(“string”);
int i=sb.capacity();

j、ensureCapacity方法
该方法的作用是重新设置字符串容量的大小。
StringBuffer sb=new StringBuffer();
sb.ensureCapacity(32); //预先设置sb的容量为32

k、getChars方法
该方法的作用是将字符串的子字符串复制给数组。
getChars(int start,int end,char chars[],int charStart);
StringBuffer sb = new StringBuffer("I love You");
int begin = 0;
int end = 5;
//注意ch字符数组的长度一定要大于等于begin到end之间字符的长度
//小于的话会报ArrayIndexOutOfBoundsException
//如果大于的话，大于的字符会以空格补齐
char[] ch = new char[end-begin];
sb.getChars(begin, end, ch, 0);
System.out.println(ch);

来源于→csdn

作者: Id_820 时间: 2015-12-14 21:49
/**
   * String其本质是采用字面值的方式赋值
   * a.在赋值的时候，会去查找String Pool中是否存在"str"这个对象，如果存在，则会直接返回该对象的地址，然后付给变量str，
   * 如果不存在，则会在String Pool中创建, 然后返回他的地址，付给str
   */
String str = "str";

/**
   * StringBuilder是一个可变的字符序列,
   * 在JDK1.5以前是没有的, 在这之前都是用的StringBuffer, 所以StringBuiler是线程不安全的, 所以在使用上比StringBuffer效率稍微高一点
   * 常见的方法：append, indexOf, insert, replace, toString等
   */
StringBuilder sb = new StringBuilder();

作者: Mykey 时间: 2015-12-14 22:11
String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下

作者: lixy 时间: 2015-12-15 22:36
楼上都从技术层面上讲的差不多了，我说一下自己常用在哪。如果是写死的字符串，就用string，而要用到拼接字符串（类似扩容的地方），就用StringBuilder

作者: a944090777 时间: 2015-12-17 08:54
String是不可变字符串，StringBuilder是可变字符串。

作者: Deemons 时间: 2015-12-17 20:06
楼上都讲的差不多了，也没什么好补充的。字符串与字符串缓冲区，可以想象成水果和水果篮子

作者: 214652440 时间: 2015-12-17 22:37
String 是一个不可变的字符序列,一旦被创建值就不能被改变. 而 StringBuffer 和 StringBuilder 是可变的
* StringBuffer 是一个线程安全的可变的字符序列,效率低
* StringBuilder 是一个线程不安全的可变的字符序列,效率高. 如果是单线程环境建议使用 StringBuilder

虽然 String 是一个应用数据类型,但是在作为参数传递的时候,是按照基本数据类型的方式进行传递,传递的是具体的值

作者: labozx 时间: 2015-12-19 00:39
String可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了存储数值不可改变的字符串。

StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用或者变量的内容不断变化，那么最好用StringBuffer

作者: zll464928406 时间: 2015-12-19 11:04
String 是不可变的对象，因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响
StringBuffer 是可变的对象，每次改变都会是对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下

作者: kingjacob 时间: 2015-12-19 16:24
String、StringBuffer、StringBuilder区别

StringBuffer、StringBuilder和String一样，也用来代表字符串。String类是不可变类，任何对String的改变都会引发新的String对象的生成；StringBuffer则是可变类，任何对它所指代的字符串的改变都不会产生新的对象。既然可变和不可变都有了，为何还有一个StringBuilder呢？相信初期的你，在进行append时，一般都会选择StringBuffer吧！

先说一下集合的故事，HashTable是线程安全的，很多方法都是synchronized方法，而HashMap不是线程安全的，但其在单线程程序中的性能比HashTable要高。StringBuffer和StringBuilder类的区别也是如此，他们的原理和操作基本相同，区别在于StringBufferd支持并发操作，线性安全的，适合多线程中使用。StringBuilder不支持并发操作，线性不安全的，不适合多线程中使用。新引入的StringBuilder类不是线程安全的，但其在单线程中的性能比StringBuffer高。

作者: 499087476 时间: 2015-12-19 20:13
学习了很受用

作者: 小妖精 时间: 2015-12-20 10:57
string 是常量，定义后不能改变，
stringbuilder定义后可以改变，且线程不安全
stringbuffer和stringbuilder一样，但是线程安全

作者: and2long 时间: 2015-12-26 21:49
进来学习一下..

作者: 1158147908 时间: 2015-12-27 08:31
String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象（为什么？问问 Java 的设计者吧，为什么 String 不是原生类型呢？）因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。这里尝试举个不是很恰当的例子：

String S1 = “abc”;
For(int I = 0 ; I < 10000 ; I ++) // For 模拟程序的多次调用
{
S1 + = “def”;
S1 = “abc”;
}

如果是这样的话，到这个 for 循环完毕后，如果内存中的对象没有被 GC 清理掉的话，内存中一共有 2 万多个了，惊人的数目，而如果这是一个很多人使用的系统，这样的数目就不算很多了，所以大家使用的时候一定要小心。

而如果是使用 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 会规规矩矩的按照原来的方式去做， S1 对象的生成速度就不像刚才那么快了，一会儿我们可以来个测试作个验证。

由此我们得到第一步结论：在大部分情况下 StringBuffer > String

而 StringBuilder 跟他们比又怎么样呢？先简单介绍一下， StringBuilder 是 JDK5.0 中新增加的一个类，它跟 StringBuffer 的区别看下面的介绍（来源 JavaWorld ）：

Java.lang.StringBuffer 线程安全的可变字符序列。类似于 String 的字符串缓冲区，但不能修改。可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。从 JDK 5.0 开始，为该类增添了一个单个线程使用的等价类，即 StringBuilder 。与该类相比，通常应该优先使用 StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

但是如果将 StringBuilder 的实例用于多个线程是不安全的。需要这样的同步，则建议使用 StringBuffer 。

这样说估计大家都能明白他们之间的区别了，那么下面我们再做一个一般性推导：

在大部分情况下 StringBuilder > StringBuffer

因此，根据这个不等式的传递定理：在大部分情况下 StringBuilder > StringBuffer > String

既然有这样的推导结果了，我们做个测试验证一下：

测试代码如下：

public class testssb {

/** Creates a new instance of testssb */
final static int ttime = 10000;// 测试循环次数
public testssb() {
}

public void test(String s){
long begin = System.currentTimeMillis();
for(int i=0;i<ttime;i++){
s += "add";
}
long over = System.currentTimeMillis();
System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： " + (over - begin) + " 毫秒 " );
}

public void test(StringBuffer s){
long begin = System.currentTimeMillis();
for(int i=0;i<ttime;i++){
s.append("add");
}
long over = System.currentTimeMillis();
System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： " + (over - begin) + " 毫秒 " );
}

public void test(StringBuilder s){
long begin = System.currentTimeMillis();
for(int i=0;i<ttime;i++){
s.append("add");
}
long over = System.currentTimeMillis();
System.out.println(" 操作 "+s.getClass().getName()+" 类型使用的时间为： " + (over - begin) + " 毫秒 " );
}

// 对 String 直接进行字符串拼接的测试
public void test2(){
String s2 = "abadf";
long begin = System.currentTimeMillis();
for(int i=0;i<ttime;i++){
String s = s2 + s2 + s2 ;
}
long over = System.currentTimeMillis();
System.out.println(" 操作字符串对象引用相加类型使用的时间为： " + (over - begin) + " 毫秒 " );
}

public void test3(){
long begin = System.currentTimeMillis();
for(int i=0;i<ttime;i++){
String s = "abadf" + "abadf" + "abadf" ;
}
long over = System.currentTimeMillis();
System.out.println(" 操作字符串相加使用的时间为： "+ (over - begin) + " 毫秒 " );
}

public static void main(String[] args){
String s1 ="abc";
StringBuffer sb1 = new StringBuffer("abc");
StringBuilder sb2 = new StringBuilder("abc");

testssb t = new testssb();
t.test(s1);
t.test(sb1);
t.test(sb2);
t.test2();
t.test3();
}
}

以上代码在 NetBeans 5.0 IDE/JDK1.6 上编译通过,循环次数 ttime 为 10000 次的测试结果如下：
操作 java.lang.String 类型使用的时间为： 4392 毫秒
操作 java.lang.StringBuffer 类型使用的时间为： 0 毫秒
操作 java.lang.StringBuilder 类型使用的时间为： 0 毫秒
操作字符串对象引用相加类型使用的时间为： 15 毫秒
操作字符串相加使用的时间为： 0 毫秒

好像还看不出 StringBuffer 和 StringBuilder 的区别，把 ttime 加到 30000 次看看：
操作 java.lang.String 类型使用的时间为： 53444 毫秒
操作 java.lang.StringBuffer 类型使用的时间为： 15 毫秒
操作 java.lang.StringBuilder 类型使用的时间为： 15 毫秒
操作字符串对象引用相加类型使用的时间为： 31 毫秒
操作字符串相加使用的时间为： 0 毫秒

StringBuffer 和 StringBuilder 的性能上还是没有太大的差异，再加大到 100000 看看，这里就不加入对 String 类型的测试了，因为对 String 类型这么大数据量的测试会很慢滴……
操作 java.lang.StringBuffer 类型使用的时间为： 31 毫秒
操作 java.lang.StringBuilder 类型使用的时间为： 16 毫秒

能看出差别了，但其中有多次的测试结果居然是 StringBuffer 比 StringBuilder 快，再加大一些到 1000000 看看（应该不会当机吧？）：
操作 java.lang.StringBuffer 类型使用的时间为： 265 毫秒
操作 java.lang.StringBuilder 类型使用的时间为： 219 毫秒

有些少区别了，而且结果很稳定，再大点看看， ttime = 5000000 ：
基本来说都是在性能上都是 StringBuilder > StringBuffer > String

作者: 1158147908 时间: 2015-12-27 08:52
对于三者使用的总结：

1.如果要操作少量的数据用 = String

2.单线程操作字符串缓冲区下操作大量数据 = StringBuilder

3.多线程操作字符串缓冲区下操作大量数据 = StringBuffer

最近学习到StringBuffer，心中有好些疑问，搜索了一些关于String，StringBuffer，StringBuilder的东西，现在整理一下。

关于这三个类在字符串处理中的位置不言而喻，那么他们到底有什么优缺点，到底什么时候该用谁呢？下面我们从以下几点说明一下

1.三者在执行速度方面的比较：StringBuilder > StringBuffer > String

2.String <（StringBuffer，StringBuilder）的原因

String：字符串常量

StringBuffer：字符创变量

StringBuilder：字符创变量

从上面的名字可以看到，String是“字符创常量”，也就是不可改变的对象。对于这句话的理解你可能会产生这样一个疑问，比如这段代码：

1Strings="abcd";

2s=s+1;

3System.out.print(s);//result:abcd1

我们明明就是改变了String型的变量s的，为什么说是没有改变呢? 其实这是一种欺骗，JVM是这样解析这段代码的：首先创建对象s，赋予一个abcd，然后再创建一个新的对象s用来执行第二行代码，也就是说我们之前对象s并没有变化，所以我们说String类型是不可改变的对象了，由于这种机制，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被ＧＣ回收掉，可想而知这样执行效率会有多底。

而StringBuffer与StringBuilder就不一样了，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，这样就不会像String一样创建一些而外的对象进行操作了，当然速度就快了。

3.一个特殊的例子：

1Stringstr=“Thisisonlya”+“simple”+“test”;

3StringBufferbuilder=newStringBuilder(“Thisisonlya”).append(“simple”).append(“test”);

你会很惊讶的发现，生成str对象的速度简直太快了，而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏，实际上： String str = “This is only a” + “ simple” + “test”; 其实就是：

String str = “This is only a simple test”;

所以不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的String对象的话，速度就没那么快了，譬如：

String str2 = “This is only a”; String str3 = “ simple”; String str4 = “ test”; String str1 = str2 +str3 + str4;

这时候JVM会规规矩矩的按照原来的方式去做。

4.StringBuilder与 StringBuffer

StringBuilder：线程非安全的

StringBuffer：线程安全的

当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。

作者: Lewisky 时间: 2016-1-5 12:09
stringbuilder是变长的。

作者: wljr339 时间: 2016-1-7 23:43
String可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了存储数值不可改变的字符串。

StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用或者变量的内容不断变化，那么最好用StringBuffer。

作者: Unique丨Gin 时间: 2016-1-12 07:58
先看一个例子
string s1 = "orange";// outputs "orangered"
string s2 = "red";

s1 += s2;
System.Console.WriteLine(s1);

s1 = s1.Substring(2, 5);
System.Console.WriteLine(s1); // outputs "anger"

大家都知道字符串对象是“不可变的”,
对字符串进行操作的方法实际上返回的是新的字符串对象。
在前面的示例中，将 s1 和 s2 的内容连接起来以构成一个字符串时，包含"orange" 和 "red" 的两个字符串均保持不变。+= 运算符会创建一个包含组合内容的新字符串。

结果是：

s1 现在引用一个完全不同的字符串。只包含"orange" 的字符串仍然存在，但连接 s1 后将不再被引用。
大量的字符串相加的时候就会有很多像s1一样的不在被引用,从而造成资源的极大浪费.

作者: 胆小的狙击手 时间: 2016-1-12 21:12
String和StringBuilder都是字符序列，都实现了CharSequence接口。

作者: 雪中飞 时间: 2016-1-12 23:16
String一旦被赋值就不能更改，StringBuilder可以更改，

作者: wljr339 时间: 2016-1-12 23:41
String可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了存储数值不可改变的字符串。

StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用或者变量的内容不断变化，那么最好用StringBuffer。
这个你可以试一下!!!

作者: 谁的苍茫 时间: 2016-1-21 23:53
String 是用于对字符串的操作，字符串一旦被赋值，就不能改变，指的是字符串的内容不能改变，而不是引用，String类里面定义了许多操作字符串的方法，而StringBuilder是因为经常需要用到字符串的拼接操作，而字符串对于拼接，比较耗时和耗内粗，所以Java才提供一个字符缓冲区类，来更方便我们操作使用，
而且有两个一个是StringBuffer，它是线程安全，效率稍低
而StringBuilder是线程不安全，效率高，一般不涉及到线程都是使用StringBuilder。

作者: 秦爽爽 时间: 2016-1-22 23:49
百度上好详细的

作者: xiaotvsit 时间: 2016-3-2 23:42
自己总结，简而言之，stringbuilder和string的区别在于：

stringbuilder是变长的。

string是定长的。

作者: wuyibo 时间: 2016-3-16 23:18
String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。
StringBuffer是同步的，数据安全，效率低；StringBuilder是不同步的，数据不安全，效率高

作者: wuyibo 时间: 2016-3-17 21:44
String可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了存储数值不可改变的字符串。 StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用或者变量的内容不断变化，那么最好用StringBuffer。

作者: hjh987099654 时间: 2016-3-18 03:16
String可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了存储数值不可改变的字符串。 StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用或者变量的内容不断变化，那么最好用StringBuffer。

作者: Ak-47 时间: 2016-3-29 01:46
String是内容长度不可变的字符数组，而StringBuffer,StringBuilder都是内容可变的,比较适合现实中的情况
StringBuffer其实在底层,String都是先通过StringBuffer来实现字符串的连接,在转换成String类型呈现出来的,

作者: 小K哥 时间: 2016-4-21 21:50
后者长度和内容可变，前者不可变。
如果使用后者做字符串的拼接，不会浪费太多的资源。

作者: linguoqun 时间: 2016-8-2 23:50
楼主，你好！很高兴为您解答：现在跟您讲一下它们两个以及StringBuffer，三个之间的区别：请看：
String类实际是使用字符数组存储的，表示出一个字符串。
String类的两种赋值方式: (1)一种称为直接赋值:
String name = “小白”
(2)通过关键字new调用String的构造方法赋值 String name = new String(“小白”)

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 要快。两者的方法基本相同。
纯手打的，满意请采纳，谢谢！

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2