String、StringBuffer、StringBuilder 的区别？

public static void main(String[] args) {
       // String 
        String str = "Hello";
        System.out.println(System.identityHashCode(str));
        String str1 = str + "word";
        System.out.println(System.identityHashCode(str1));

       // StringBuilder
        StringBuilder sb = new StringBuilder("Hello");
        System.out.println(System.identityHashCode(sb));
        StringBuilder sb1 = sb.append("word");
        System.out.println(System.identityHashCode(sb1));

       // StringBuffer
        StringBuffer sbf = new StringBuffer("Hello");
        System.out.println(System.identityHashCode(sbf));
        StringBuffer sbf1 = sbf.append("word");
        System.out.println(System.identityHashCode(sbf1));

    }

输出结果:
    23934342
    22307196
    10568834
    10568834
    21029277
    21029277

// 此方法中可以看到String是不可变，每次修改操作都会创建一个新的字符串对象，而StringBuffer、StringBuilder每次修改都不会改变自身的地址。

 * Strings are constant; their values cannot be changed after they
 * are created. String buffers support mutable strings.
 * Because String objects are immutable they can be shared. 

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0
}

 * A thread-safe, mutable sequence of characters.
 * A string buffer is like a {@link String}, but can be modified.

 * The principal operations on a {@code StringBuffer} are the
 * {@code append} and {@code insert} methods, which are
 * overloaded so as to accept data of any type.

 * 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.

    @Override
    public synchronized StringBuffer append(Object obj) {
        toStringCache = null;
        super.append(String.valueOf(obj));
        return this;
    }

    @Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }

 * A mutable sequence of characters.  This class provides an API compatible
 * with {@code StringBuffer}, but with no guarantee of synchronization.
 * This class is designed for use as a drop-in replacement for
 * {@code StringBuffer} in places where the string buffer was being
 * used by a single thread (as is generally the case).   Where possible,
 * it is recommended that this class be used in preference to
 * {@code StringBuffer} as it will be faster under most implementations.

 * Instances of {@code StringBuilder} are not safe for
 * use by multiple threads. If such synchronization is required then it is
 * recommended that {@link java.lang.StringBuffer} be used.

    @Override
    public StringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }

    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }