String StringBuffer StringBuilder之间的区别

相信大家看到过很多比较String和StringBuffer区别的文章，也明白这两者的区别，然而自从Java 5.0发布以后，我们的比较列表上将多出一个对象了，这就是StringBuilder类。String类是不可变类，任何对String的改变都会引发新的String对象的生成；而StringBuffer则是可变类，任何对它所指代的字符串的改变都不会产生新的对象，可变和不可变类这一对对象已经齐全了，那么为什么还要引入新的StringBuilder类干吗？相信大家都有此疑问，我也如此。下面，我们就来看看引入该类的原因。
      为什么会出现那么多比较String和StringBuffer的文章？

      原因在于当改变字符串内容时，采用StringBuffer能获得更好的性能。既然是为了获得更好的性能，那么采用StringBuffer能够获得最好的性能吗？

      答案是NO！

      为什么？

      如果你读过《Think in Java》，而且对里面描述HashTable和HashMap区别的那部分章节比较熟悉的话，你一定也明白了原因所在。对，就是支持线程同步保证线程安全而导致性能下降的问题。HashTable是线程安全的，很多方法都是synchronized方法，而HashMap不是线程安全的，但其在单线程程序中的性能比HashTable要高。StringBuffer和StringBuilder类的区别也在于此，新引入的StringBuilder类不是线程安全的，但其在单线程中的性能比StringBuffer高。

package cn.edu.lstc.stringbuffer;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class StringBuilderTest {
private static final String base = "base string.";
private static final int count = 2000000;

/**
* 测试String类
*/
public static void stringTest() {
long begin, end;
begin = System.currentTimeMillis();// 开始时间
String test = new String(base);
for (int i = 0; i < count / 100; i++) {
test = test + " add";
}
end = System.currentTimeMillis();// 结束时间
System.out.println("当用String类来操作字符串时耗时:" + (end - begin) + "毫秒");
}

/**
* 测试StringBuffer类
*/
public static void stringBufferTest() {
long begin, end;
begin = System.currentTimeMillis();
StringBuffer test = new StringBuffer(base);
for (int i = 0; i < count; i++) {
test = test.append(" add");
}
end = System.currentTimeMillis();
System.out.println("当用StringBuffer来操作字符串时耗时:" + (end - begin) + "毫秒");
}

/**
* 测试StringBuilder类
*/
public static void stringBuilderTest() {
long begin, end;
begin = System.currentTimeMillis();// 开始时间
StringBuilder test = new StringBuilder(base);
for (int i = 0; i < count; i++) {
test = test.append(" add");
}
end = System.currentTimeMillis();
System.out.println("当用StringBuilder来操作字符串时耗时:" + (end - begin) + "毫秒");
}

public static String appendItemsToStringBuilder(List list) {
StringBuilder builder = new StringBuilder();
Iterator iterator = null;
for (iterator = list.iterator(); iterator.hasNext();) {
builder.append(iterator.next()).append(" ");
}
return builder.toString();
}

public static void addToStringBuilder() {
List<String> list = new ArrayList<String>();
list.add("I ");
list.add(" play ");
list.add(" Basketball ");
list.add(" and ");
list.add(" PingPongball ");

System.out.println(StringBuilderTest.appendItemsToStringBuilder(list));
}

public static String appendItemsToStringBuffer(List list) {
StringBuffer buffer = new StringBuffer();
Iterator iterator = null;
for (iterator = list.iterator(); iterator.hasNext();) {
buffer.append(iterator.next()).append(" ");
}
return buffer.toString();
}

public static void addToStringBuffer(){
List<String> list = new ArrayList<String>();
list.add("I ");
list.add(" play ");
list.add(" Basketball ");
list.add(" and ");
list.add(" PingPongball ");

System.out.println(StringBuilderTest.appendItemsToStringBuffer(list));
}

//主方法Main
public static void main(String[] args) {
stringTest();//

stringBufferTest();

stringBuilderTest();

addToStringBuffer();

addToStringBuilder();
}
}


output：
当用String类来操作字符串时耗时:880毫秒
当用StringBuffer来操作字符串时耗时:70毫秒
当用StringBuilder来操作字符串时耗时:30毫秒
I play Basketball and PingPongball
I play Basketball and PingPongball

从上面的结果来看，这三个类在单线程程序中的性能差别一目了然，采用String对象时，即使运行次数仅是采用其他对象的1/100，其执行时间仍然比其他对象高出25倍以上；而采用StringBuffer对象和采用StringBuilder对象的差别也比较明显，前者是后者的1.5倍左右。由此可见，如果我们的程序是在单线程下运行，或者是不必考虑到线程同步问题，我们应该优先使用StringBuilder类；当然，如果要保证线程安全，自然非StringBuffer莫属了。
除了对多线程的支持不一样外，这两个类的使用几乎没有任何差别，上面的例子就是个很好的说明。appendItemsToStringBuiler和appendItemsToStirngBuffer两个方法除了采用的对象分别为StringBuilder和StringBuffer外，其他完全相同，而效果也完全相同。

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

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

　　　　String：字符串常量

　　　　StringBuffer：字符创变量

　　　　StringBuilder：字符创变量

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

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

 

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

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

　　3.一个特殊的例子：

1 String str = “This is only a” + “ simple” + “ test”;
3 StringBuffer builder = new StringBuilder(“This is only a”).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的，就是速度的原因。

 

           对于三者使用的总结： 1.如果要操作少量的数据用 = String

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

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