String, StringBuffer, StringBuilder的区别

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 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。 
例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。 

下面的文章来自：http://book.csdn.net/bookfiles/135/1001354628.shtml 
StringBuilder类: 
一个String对象的长度是固定的，不能改变它的内容，或者是附加新的字符至String对象中。您也许会使用+来串联字符串以达到附加新字符或字符串的目的，但+会产生一个新的String实例。如果程序对这种附加字符串的需求很频繁，并不建议使用+来进行字符串的串联。在面向对象程序设计中，最好是能重复运用已生成的对象，对象的生成需要内存空间与时间，不断地产生String实例是一个没有效率的行为。 

J2SE 5.0提供java.lang.StringBuilder类，使用这个类所产生的对象默认会有16个字符的长度，您也可以自行指定初始长度。如果附加的字符超出可容纳的长度，则StringBuilder对象会自动增加长度以容纳被附加的字符。如果有频繁作字符串附加的需求，使用StringBuilder会让程序的效率大大提高。通过下面的简单测试程序就可以知道效能差距有多大。 

Ü 范例6.5  AppendStringTest.java                                                      

Java代码 

1. public class AppendStringTest {   
2.   
3.     public static void main(String[] args) {   
4.   
5.         String text = "";   
6.   
7.     
8.   
9.         long beginTime = System.currentTimeMillis();   
10.   
11.         for(int i = 0; i < 10000; i++)   
12.   
13.             text = text + i;   
14.   
15.         long endTime = System.currentTimeMillis();   
16.   
17.         System.out.println("执行时间：" + (endTime - beginTime));   
18.   
19.     
20.   
21.         StringBuilder builder = new StringBuilder("");   
22.   
23.         beginTime = System.currentTimeMillis();   
24.   
25.         for(int i = 0; i < 10000; i++)   
26.   
27.             builder.append(String.valueOf(i));   
28.   
29.         endTime = System.currentTimeMillis();   
30.   
31.         System.out.println("执行时间：" + (endTime - beginTime));   
32.   
33.     }   
34.   
35. }  

在范例6.5中首先使用+来串联字符串，使用System.currentTimeMillis()取得for循环执行前、后的系统时间，这样就可以得知for循环执行了多久。以下是我的计算机上的测试数据： 



执行时间：4641 

执行时间：16 

可以看到执行的时间差距很大，这说明了使用+串联字符串所带来的负担。如果有经常作附加字符串的需求，建议使用StringBuilder。事实上就范例6.5来说，第二个for循环执行时间还可以更短，因为append()也可以接受基本数据类型，所以不必特地使用String.valueOf()方法从int取得String。改为以下的方式，执行时间可以大幅缩短： 

for(int i = 0; i < 10000; i++)    builder.append(i);使用StringBuilder最后若要输出字符串结果，可以用toString()方法。可以使用length()方法得知目前对象中的字符长度，而capacity()可返回该对象目前可容纳的字符容量。另外，StringBuilder还有像insert()方法可以将字符插入指定的位置，如果该位置以后有字符，则将所有的字符往后移；deleteChar()方法可以删除指定位置的字符，而reserve()方法可以反转字符串。详细的使用可以查询java.lang.StringBuilder的API文件说明。 

StringBuilder是J2SE 5.0才新增的类，在J2SE 5.0之前的版本若有相同的需求，则使用java.lang.StringBuffer。事实上，StringBuilder被设计为与StringBuffer具有相同的操作接口。在单机非多线程(Multithread)的情况下使用StringBuilder会有较好的效率，因为StringBuilder没有处理同步(Synchronized)问题。StringBuffer则会处理同步问题，如果StringBuilder会在多线程下被操作，则要改用StringBuffer，让对象自行管理同步问题。关于多线程的概念，会在第15章详细说明。 

下面的文章来自：http://www.javaeye.com/topic/142364 
今天有空，下了scjp的题目做做，想起了一个本来想写却又没写的问题。这个问题几乎已成为面试必问题，虽然答案很简单，但回答出确又真正理解的人我觉得并不多。 

String与StringBuffer的区别？ 

如果你在网上一搜，会有非常多的答案，其中最多的就是String是不可变而StringBuffer是可变的，但是这可变与不可变究竟是什么意思呢？如果你能用IDE进行debug的话，你就会发现，String实例化以后所有的属性都是final的，而StringBuffer确不是，这就是可变与不可变。下面引用SCJP的试题来解释一下这个例子： 

java 代码 

Java代码 

1. public class Test {       
2.    public static void stringReplace (String text) {       
3.    text = text.replace('j' , 'i');        
4.    }       
5.           
6.    public static void bufferReplace (StringBuffer text) {       
7.    text = text.append("C");        
8.    }       
9.           
10.     public static void main (String args[]) {        
11.     String textString = new String ("java");        
12.     StringBuffer textBuffer = new StringBuffer ("java");        
13.            
14.     stringReplace (textString);        
15.     bufferReplace (textBuffer);        
16.            
17.     System.out.println (textString + textBuffer);        
18.     }        
19.     }     

答案是 javajavaC 

这是因为第七行text = text.append ("C")，append方法会改变text中的值,而text与textBuffer指向的地址是相同的。因此会打印javaC 

再举个例子： 

String a = "a";  //假设a指向地址0x0001 

a = "b";//重新赋值后a指向地址0x0002，但0x0001地址中保存的"a"依旧存在，但已经不再是a所指向的。 

因此String的操作都是改变赋值地址而不是改变值操作 
loveexception: 
foy 写道 
SINCE1978 写道 
没看懂 
public static void stringReplace (String text) {    
   text = text.replace('j' , 'i');     
}——这个方法根本不起作用因为text只是引用拷贝。 
似乎是在讲参数传递问题？和可变不可变对象有啥关系？ 


不是引用拷贝,两个对象指向同一段内存 


string是不可变的。。。 
比如这个： 
test(x000001).replace(“j”,"i"); 

内部分是这样的： 
Java代码 

Java代码 

1. String reqlace("j","i"){      
2.  //self="java";      
3.  // .......dosomthing      
4.  return new String ("iava");//看到这个new 了么？      
5. }  

  

星情泪: 
Java代码 

Java代码 

1. public class Test {      
2.     public static void stringReplace(String text) {      
3.         //把textString的地址copy给text,text也指向了textString的"java"      
4.         //text.replace('j', 'i');的结果是"iava"      
5.         //text = text.replace('j', 'i');就是重新使text指向"iava"      
6.         //由于该方法的返回类型是void,所以原来的textString没变      
7.         text = text.replace('j', 'i');      
8.     }      
9.      
10.     public static void bufferReplace(StringBuffer text) {      
11.         //textBuffer的地址copy给text      
12.         //然后沿着text指向的字符串(其实也就是textBuffer指向的对象)操作,添加一个"C"      
13.         //虽然没有任何返回,但是这个操作影响到了textBuffer所指向的字符串      
14.         //所以上个方法打印"java",这个方法打印"javaC"      
15.         text = text.append("C");      
16.     }      
17.      
18.     public static void main(String args[]) {      
19.         String textString = new String("java");      
20.         StringBuffer textBuffer = new StringBuffer("java");      
21.      
22.         stringReplace(textString);      
23.         bufferReplace(textBuffer);      
24.      
25.         System.out.println(textString + textBuffer);      
26.     }      
27. }