java 基础知识——String & StringBuffer & StringBuilder

String类是不可变类，任何对String的改变都会引发新的String对象的生成；

StringBuffer则是可变类，任何对它所指代的字符串的改变都不会产生新的对象，可变和不可变类这一对对象已经齐全了。

然而自从Java 5.0发布以后，我们的比较列表上将多出一个对象了，这就是StringBuilder类。

为什么会出现那么多比较String和StringBuffer的文章？

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

答案是NO！

      为什么？

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

1. String 类 
　　String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且大量浪费有限的内存空间。 
String a = "a";         //假设a指向地址0x0001 
a = "b";                   //重新赋值后a指向地址0x0002，但0x0001地址中保存的"a"依旧存在，但已经不再是a所指向的,a 已经指向了其它地址。 
因此String的操作都是改变赋值地址而不是改变值操作。 

2. StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。 每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量。 

StringBuffer buf=new StringBuffer(); //分配长16字节的字符缓冲区 
StringBuffer buf=new StringBuffer(512); //分配长512字节的字符缓冲区 
StringBuffer buf=new StringBuffer("this is a test")//在缓冲区中存放了字符串，并在后面预留了16字节的空缓冲区。 

3.StringBuilder 
　　StringBuffer和StringBuilder类功能基本相似，主要区别在于StringBuffer类的方法是多线程、安全的，而StringBuilder不是线程安全的，相比而言，StringBuilder类会略微快一点。对于经常要改变值的字符串应该使用StringBuffer和StringBuilder类。 

4.线程安全 
StringBuffer 线程安全 
StringBuilder 线程不安全 

5.速度 
一般情况下,速度从快到慢:StringBuilder>StringBuffer>String,这种比较是相对的，不是绝对的。 

6.总结 
（1）如果要操作少量的数据用 = String 
（2）单线程操作字符串缓冲区 下操作大量数据 = StringBuilder 
（3）多线程操作字符串缓冲区 下操作大量数据 = StringBuffer 

如果你对此不太相信，可以试试下面的例子：

package com.cn;

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;

   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((end - begin)
              + " millis has elapsed when used String. ");
 }

   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((end - begin)
              + " millis has elapsed when used StringBuffer. ");
 }

 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((end - begin)
                + " millis has elapsed when used StringBuilder. ");
 }

 public static String appendItemsToStringBuiler(List list) {
          StringBuilder b = new StringBuilder();

          for (Iterator i = list.iterator(); i.hasNext();) {
                  b.append(i.next()).append(" ");
             }

           return b.toString();
 }

 public static void addToStringBuilder() {
  List list = new ArrayList();
  list.add(" I ");
  list.add(" play ");
  list.add(" Bourgeois ");
  list.add(" guitars ");
  list.add(" and ");
  list.add(" Huber ");
  list.add(" banjos ");

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

 public static String appendItemsToStirngBuffer(List list) {
  StringBuffer b = new StringBuffer();

  for (Iterator i = list.iterator(); i.hasNext();) {
   b.append(i.next()).append(" ");
  }

  return b.toString();
 }

 public static void addToStringBuffer() {
  List list = new ArrayList();
  list.add(" I ");
  list.add(" play ");
  list.add(" Bourgeois ");
  list.add(" guitars ");
  list.add(" and ");
  list.add(" Huber ");
  list.add(" banjos ");

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

 public static void main(String[] args) {
  stringTest();
  stringBufferTest();
  stringBuilderTest();
  addToStringBuffer();
  addToStringBuilder();
 }
}

从上面的结果来看，这三个类在单线程程序中的性能差别一目了然，采用String对象时，即使运行次数仅是采用其他对象的1/100，其执行时间仍然比其他对象高出25倍以上；而采用StringBuffer对象和采用StringBuilder对象的差别也比较明显，前者是后者的1.5倍左右。

由此可见，如果我们的程序是在单线程下运行，或者是不必考虑到线程同步问题，我们应该优先使用StringBuilder类；

当然，如果要保证线程安全，自然非StringBuffer莫属了。