参考链接： 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