整理下java中stringBuilder和stringBuffer两个类的区别

参考链接： Java中的StringBuffer类

StringBuilder和StringBuffer这两个类在动态拼接字符串时常用，肯定比String的效率和开销小，这是因为String的对象不会回收哦。 

 其实我一直用StringBuilder这个类，因为可以简写为sb的变量在程序里很爽，可是后来师兄说web程序特别是高并发的程序中不要用stringbuilder，因为简单说，stringBuilder不是线程安全的，而StirngBuffer就是线程安全的。从网上看到Stringbuffer中方法大都采用了synchronized的关键字修饰。 

 来来来，我们先复习下syncronized的用法，有篇博客写的挺好的，给个链接 http://leo-faith.iteye.com/blog/177779 

  1、synchronized关键字的作用域有二种： 1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法； 2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

  2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象；

  3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

 好了，言归正传，我们继续StringBuffer和StringBuilder的区别。 

 就是说，StringBuffer中所有的方法都要加锁，所以好多操作看上去都是线性操作的。所以要慢些。 

  一般情况下,速度从快到慢:StringBuilder>StringBuffer>String.当需要在循环中多次使用字符串拼接时,建议使用StringBuilder或StringBuffer.当数量级在百万级(这里可能不准确)时,StringBuilder的速度会体现出来.

以下是实验数据 

    01 final static int ttime = 30000;// 测试循环次数 

    02   

    03     public void test(String s) { 

    04         long begin = System.currentTimeMillis(); 

    05         for (int i = 0; i < ttime; i++) { 

    06             s += "add"; 

    07         } 

    08         long over = System.currentTimeMillis(); 

    09         System.out.println(" 操作 " + s.getClass().getName() + " 类型使用的时间为： " + (over - begin) + " 毫秒 "); 

    10     } 

    11   

    12     public void test(StringBuffer s) { 

    13         long begin = System.currentTimeMillis(); 

    14         for (int i = 0; i < ttime; i++) { 

    15             s.append("add"); 

    16         } 

    17         long over = System.currentTimeMillis(); 

    18         System.out.println(" 操作 " + s.getClass().getName() + " 类型使用的时间为： " + (over - begin) + " 毫秒 "); 

    19     } 

    20   

    21     public void test(StringBuilder s) { 

    22         long begin = System.currentTimeMillis(); 

    23         for (int i = 0; i < ttime; i++) { 

    24             s.append("add"); 

    25         } 

    26         long over = System.currentTimeMillis(); 

    27         System.out.println(" 操作 " + s.getClass().getName() + " 类型使用的时间为： " + (over - begin) + " 毫秒 "); 

    28     } 

    29   

    30     // 对 String 直接进行字符串拼接的测试 

    31     public void test2() { 

    32         String s2 = "abadf"; 

    33         long begin = System.currentTimeMillis(); 

    34         for (int i = 0; i < ttime; i++) { 

    35             String s = s2 + s2 + s2; 

    36         } 

    37         long over = System.currentTimeMillis(); 

    38         System.out.println(" 操作字符串对象引用相加类型使用的时间为： " + (over - begin) + " 毫秒 "); 

    39     } 

    40   

    41     public void test3() { 

    42         long begin = System.currentTimeMillis(); 

    43         for (int i = 0; i < ttime; i++) { 

    44             String s = "abadf" + "abadf" + "abadf"; 

    45         } 

    46         long over = System.currentTimeMillis(); 

    47         System.out.println(" 操作字符串相加使用的时间为： " + (over - begin) + " 毫秒 "); 

    48     } 

    49   

    50     public static void main(String[] args) { 

    51         String s1 = "abc"; 

    52         StringBuffer sb1 = new StringBuffer("abc"); 

    53         StringBuilder sb2 = new StringBuilder("abc"); 

    54         Test t = new Test(); 

    55         t.test(s1); 

    56         t.test(sb1); 

    57         t.test(sb2); 

    58         t.test2(); 

    59         t.test3(); 

    60     } 

试验结果如下： 

  操作 java.lang.String 类型使用的时间为： 2432 毫秒  

  操作 java.lang.StringBuffer 类型使用的时间为： 3 毫秒  

  操作 java.lang.StringBuilder 类型使用的时间为： 3 毫秒  

  操作字符串对象引用相加类型使用的时间为： 6 毫秒  

  操作字符串相加使用的时间为： 1 毫秒  

 把循环次数调的很大，试了用下jconsle来监视内存GC，第一次使用，不太明白，有个博客写的很好的，有空研究一下 

  http://jiajun.iteye.com/blog/810150 

 再补充一个Jstat的工具 http://xiaolele.iteye.com/blog/592022 

 /** 

 *20120516昨天忘看源代码了 

 **/ 

 StringBuffer中append方法有很多重载，有synchronized关键字没错，主要调用的还是AbstractStringBuilder的super的方法。 

    1 public synchronized StringBuffer append(String s) 

    2 { 

    3     super.append(s); 

    4     return this; 

    5 } 

父类的方法为 

    01 public AbstractStringBuilder append(String s) { 

    02   

    03     if (s == null) 

    04         s = "null"; 

    05     int i = s.length(); 

    06     if (i == 0) 

    07         return this; 

    08     int j = count + i; 

    09     if (j > value.length) 

    10         expandCapacity(j); 

    11     s.getChars(0, i, value, count); 

    12     count = j; 

    13     return this; 

    14 } 

 StringBuilder类中的append就没有同步的关键字了。父类的方法基本上差不多。 

 总结一下，StringBuffer线程安全，内部有synchronized方法，StringBuilder是1.5之后出来的，高并发就不要用了。另外synchronized的使用要熟悉，以后研究下java内存的工具，比如jconsle。 

 转载：http://my.oschina.net/zimingforever/blog/57514