String与StringBuilder，StringBuffer

1. 首先要清楚final的含义：被final修饰的变量，如果该变量是基本数据类型，则该变量的值无法改变；如果该变量是引用数据类型，则仅仅表示该变量所引用的对象的地址是不变的，但是，引用的对象的内容是可能发生改变的。

原理：java中引用类型存储，均存储的是引用地址，而非引用对象本身。

如上图，引用类型obj用final修饰，仅仅表示，一旦obj进行初始化，指向了0x123，则不能修改，不能再引用别的地址，一旦引用，编译报错！引用的对象的内容实质是一个Object数组，为Object[]{a,b,c}， 在这里，因为a, b, c也只是存放的对象的地址，且没有用final修饰，所以其引用可以进行任意改变。一旦改变，则实际上对象obj的内容是发生改变的，但是obj的引用地址未发生改变。

2. String

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

我们知道，String实际是对char[] 字符数组的封装，而变量value就是具体存放的char[]，但是这里value用了final修饰（其初始化是在构造器中实现），虽然value的引用地址不能改变，但是其实value的值是可以修改的，只是String的设计本意不是让我们通过修改value的值去修改String本身。而是在方法中，以value为源数据，通过数组复制等操作生成新的char[]，并生成新的String对象。如：

//字符串拼接操作，最后生成new String
public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);
    }

这样做的弊端就是，每生成一个新的String，都需要在堆内存中开辟一个内存空间用于存储。而之前不用的旧的String对象就要等待gc去清除，效率较低。

3. StringBuilder

首先，StringBuilder继承了AbstractStringBuilder类（很重要）

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char[] value;

可以看到，在AbstractStringBuilder类中，用于存储char[] 字符数组的变量value没有用final修饰，这就意味着，value可以任意修改引用地址，我们称其为动态数组（ArrayList也是该原理）。与String相同，我们以value为源，通过数组复制等操作生成新的char[] 字符数组，并将value重新指向生成的新数组(这里与String不同，因为String的value使用final修饰了，不能修改其引用地址)。如：

 public AbstractStringBuilder append(char[] str) {
        int len = str.length;
        ensureCapacityInternal(count + len);//在确保容量时也是对value的扩容
        System.arraycopy(str, 0, value, count, len);//该方法的第三个参数是复制的目标数组
        count += len;
        return this; // 添加后将对象本身返回，String中是新生成String对象返回
    }

 /**
     * This method has the same contract as ensureCapacity, but is
     * never synchronized.
     */
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0)
            expandCapacity(minimumCapacity);
    }

 /**
     * This implements the expansion semantics of ensureCapacity with no
     * size check or synchronization.
     */
    void expandCapacity(int minimumCapacity) {
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        value = Arrays.copyOf(value, newCapacity);//该处表明将扩容后的新字符数组重新赋值给value
    }

4. StringBuffer

StringBuffer同样继承了AbstractStringBuilder，底层与StringBuilder类似，只是多数方法保证了线程安全，从而效率相比StringBuilder降低了一些。

public final class StringBuffer
    extends AbstractStringBuilder  //同样继承了该类
    implements java.io.Serializable, CharSequence  


    public synchronized int length() { //使用synchronized修饰符
        return count;
    }

    public synchronized int capacity() { //使用synchronized修饰符
        return value.length;
    }


    public synchronized void ensureCapacity(int minimumCapacity) { //使用了synchronized修饰符
        if (minimumCapacity > value.length) {
            expandCapacity(minimumCapacity);
        }
    }