StringBuffer和StringBuilder区别？

1. String是不可变类，改变String变量中的值，相当于开辟了新的空间存放新的string变量

2. StringBuffer 可变的类，可以通过append方法改变变量的值，且StringBuffer是线程安全的，它的很多方法都是同步方法，支持并发操作，适用于多线程　　　　

3. StringBuilder 可变的类，但是线程不安全的，用于单线程中性能高于StringBuffer

4. HashTable 线程安全的，HashMap线程不安全的

为什么StringBuffer是同步的？

因为很多方法都是synchronized 。。。

 /*
  * @(#)StringBuffer.java    1.101 05/11/17
  *
  * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  */

 package java.lang;

 /**
  * A thread-safe, mutable sequence of characters.
  * A string buffer is like a {@link String}, but can be modified. At any
  * point in time it contains some particular sequence of characters, but
  * the length and content of the sequence can be changed through certain
  * method calls.
  * <p>
  * String buffers are safe for use by multiple threads. The methods
  * are synchronized where necessary so that all the operations on any
  * particular instance behave as if they occur in some serial order
  * that is consistent with the order of the method calls made by each of
  * the individual threads involved.
  * <p>
  * The principal operations on a <code>StringBuffer</code> are the
  * <code>append</code> and <code>insert</code> methods, which are
  * overloaded so as to accept data of any type. Each effectively
  * converts a given datum to a string and then appends or inserts the
  * characters of that string to the string buffer. The
  * <code>append</code> method always adds these characters at the end
  * of the buffer; the <code>insert</code> method adds the characters at
  * a specified point.
  * <p>
  * For example, if <code>z</code> refers to a string buffer object
  * whose current contents are "<code>start</code>", then
  * the method call <code>z.append("le")</code> would cause the string
  * buffer to contain "<code>startle</code>", whereas
  * <code>z.insert(4, "le")</code> would alter the string buffer to
  * contain "<code>starlet</code>".
  * <p>
  * In general, if sb refers to an instance of a <code>StringBuffer</code>,
  * then <code>sb.append(x)</code> has the same effect as
  * <code>sb.insert(sb.length(), x)</code>.
  * <p>
  * Whenever an operation occurs involving a source sequence (such as
  * appending or inserting from a source sequence) this class synchronizes
  * only on the string buffer performing the operation, not on the source.
  * <p>
  * Every string buffer has a capacity. As long as the length of the
  * character sequence contained in the string buffer does not exceed
  * the capacity, it is not necessary to allocate a new internal
  * buffer array. If the internal buffer overflows, it is
  * automatically made larger.
  *
  * As of  release JDK 5, this class has been supplemented with an equivalent
  * class designed for use by a single thread, {@link StringBuilder}.  The
  * <tt>StringBuilder</tt> class should generally be used in preference to
  * this one, as it supports all of the same operations but it is faster, as
  * it performs no synchronization.
  *
  * @author    Arthur van Hoff
  * @version     1.101, 11/17/05
  * @see     java.lang.StringBuilder
  * @see     java.lang.String
  * @since   JDK1.0
  */
  public final class StringBuffer
     extends AbstractStringBuilder
     implements java.io.Serializable, CharSequence
 {

     /** use serialVersionUID from JDK 1.0.2 for interoperability */
     static final long serialVersionUID = 3388685877147921107L;

     /**
      * Constructs a string buffer with no characters in it and an
      * initial capacity of 16 characters.
      */
     public StringBuffer() {
     super(16);
     }

     /**
      * Constructs a string buffer with no characters in it and
      * the specified initial capacity.
      *
      * @param      capacity  the initial capacity.
      * @exception  NegativeArraySizeException  if the <code>capacity</code>
      *               argument is less than <code>0</code>.
      */
     public StringBuffer(int capacity) {
     super(capacity);
     }

     /**
      * Constructs a string buffer initialized to the contents of the
      * specified string. The initial capacity of the string buffer is
      * <code>16</code> plus the length of the string argument.
      *
      * @param   str   the initial contents of the buffer.
      * @exception NullPointerException if <code>str</code> is <code>null</code>
      */
     public StringBuffer(String str) {
     super(str.length() + 16);
     append(str);
     }

     /**
      * Constructs a string buffer that contains the same characters
      * as the specified <code>CharSequence</code>. The initial capacity of
      * the string buffer is <code>16</code> plus the length of the
      * <code>CharSequence</code> argument.
      * <p>
      * If the length of the specified <code>CharSequence</code> is
      * less than or equal to zero, then an empty buffer of capacity
      * <code>16</code> is returned.
      *
      * @param      seq   the sequence to copy.
      * @exception NullPointerException if <code>seq</code> is <code>null</code>
      * @since 1.5
      */
     public StringBuffer(CharSequence seq) {
         this(seq.length() + 16);
         append(seq);
     }

     public synchronized int length() {
     return count;
     }

     public synchronized int capacity() {
     return value.length;
     }

     ...

既然StringBuffer是线程同步的，那么代价就是损失性能，摘自一个测试http://blog.sina.com.cn/s/blog_5749ead90100b7lq.html

public class TestBufferAndBuilder {
 public static void main(String[] args) {

  String randoms[] = { String.valueOf(Math.random()), String.valueOf(Math.random()), String.valueOf(Math.random()), String.valueOf(Math.random()),
    String.valueOf(Math.random()), String.valueOf(Math.random()), String.valueOf(Math.random()), String.valueOf(Math.random()), String.valueOf(Math.random()),
    String.valueOf(Math.random()) };

  System.gc();
  long d = System.currentTimeMillis();
  for (int i = 0; i < 1000000; i++) {
   StringBuffer buffer = new StringBuffer();
   buffer.append(randoms[0]).append(randoms[1]).append(randoms[2]).append(randoms[3]).append(randoms[4]).append(randoms[5]).append(randoms[6]).append(randoms[7]).append(
     randoms[8]).append(randoms[9]);
  }
  System.err.println(System.currentTimeMillis() - d);
  System.gc();

  d = System.currentTimeMillis();
  for (int i = 0; i < 1000000; i++) {
   StringBuilder builder = new StringBuilder();
   builder.append(randoms[0]).append(randoms[1]).append(randoms[2]).append(randoms[3]).append(randoms[4]).append(randoms[5]).append(randoms[6]).append(randoms[7]).append(
     randoms[8]).append(randoms[9]);
  }
  System.err.println(System.currentTimeMillis() - d);

  System.gc();
  d = System.currentTimeMillis();
  for (int i = 0; i < 1000000; i++) {
   StringBuffer buffer = new StringBuffer(200);
   buffer.append(randoms[0]).append(randoms[1]).append(randoms[2]).append(randoms[3]).append(randoms[4]).append(randoms[5]).append(randoms[6]).append(randoms[7]).append(
     randoms[8]).append(randoms[9]);
  }
  System.err.println(System.currentTimeMillis() - d);
  System.gc();

  d = System.currentTimeMillis();
  for (int i = 0; i < 1000000; i++) {
   StringBuilder builder = new StringBuilder(200);
   builder.append(randoms[0]).append(randoms[1]).append(randoms[2]).append(randoms[3]).append(randoms[4]).append(randoms[5]).append(randoms[6]).append(randoms[7]).append(
     randoms[8]).append(randoms[9]);
  }
  System.err.println(System.currentTimeMillis() - d);

 }
}

输出结果：

3188
    3657
    1672
    1859

结果如上，基本上要慢10-20%