StringBuffer是可变的还是不可变的？

前言：我们知道String类的修饰符是final，其char[] value也是由final修饰的，每次给String变量赋一个新值，都会创建一个新的String对象，很多有涉及到字符串本身的改变都是伴有(new String)的字样，所以我们说String类是不可变类。但StringBuffer类也是由final修饰的呀，为什么它就是可变类了呢？

public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
　　@Override
　　public synchronized StringBuffer append(String str) 
　　{
　　　　toStringCache = null;
　　　　super.append(str);
　　　　return this;

　　　}

}

　　在此处可以看出StringBuffer的append功能是继承其父类AbstractStringBuilder的append方法。

 public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
 }

　　private void ensureCapacityInternal(int minimumCapacity) {
　　// overflow-conscious code
　　　　if (minimumCapacity - value.length > 0)
　　　　　　expandCapacity(minimumCapacity);
　　}

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);
    }

　　此处我们可以知道，在AbstractStringBuilder中append方法的实现，是确定容器"capacity"的大小，便于下面value（在StringBuffer中value是没有final修饰符的）的重新赋值，所以这一步我们可以看作类似“踩点”的行为。接下来才是真正的力量：

 public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(, len, value, count);
        count += len;
        return this;
 }

public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
        if (srcBegin < 0) {
            throw new StringIndexOutOfBoundsException(srcBegin);
        }
        if (srcEnd > value.length) {
            throw new StringIndexOutOfBoundsException(srcEnd);
        }
        if (srcBegin > srcEnd) {
            throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
        }
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }

     * @param      src      the source array.
     * @param      srcPos   starting position in the source array.
     * @param      dest     the destination array.
     * @param      destPos  starting position in the destination data.
     * @param      length   the number of array elements to be copied.
     * @exception  IndexOutOfBoundsException  if copying would cause
     *               access of data outside array bounds.
     * @exception  ArrayStoreException  if an element in the <code>src</code>
     *               array could not be stored into the <code>dest</code> array
     *               because of a type mismatch.
     * @exception  NullPointerException if either <code>src</code> or
     *               <code>dest</code> is <code>null</code>.
     */
    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

　　可以看出真正进行“增长字符串”的操作是由系统方法arraycopy实现的，其中：

　　　　value是传入的String str的值，也就是要添加进来的字符串；

　　　　srcBegin是指，指定的字符数组dst要在value的哪个位置插入；

　　　　dst是将要被插入的字符数组；

　　　　dstBegin是字符数组的起始位置；

　　　　srcEnd-srcBegin是value的长度。

　　也就是说，StringBuffer的append的实现其实是System类中的arraycopy方法实现的，有点好奇arraycopy方法是怎么实现的，参考了https://blog.csdn.net/angjunqiang/article/details/42031351的图解，这里的浅复制就是指复制引用值，与其相对应的深复制就是复制对象的内容和值：

　　所以我们可以知道，StringBuffer为什么是可变类。因为StringBuffer的append方法的底层实现就是创建一个新的目标对象，然后将各个字符引用串接起来，这就是一个新的对象了，本质上就是栈多了一个变量，而堆上面并没有变化（为什么是在栈上呢？因为触发到的arraycopy方法是native的，也就是其生成的变量会放到本地方法栈上面去）。

　　那为什么我们没有把StringBuffer划分为不可变类呢？它明明在栈中创建了一个新的对象。因为一般的对象和数组都会在堆中进行存储，除非是发生了栈上分配现象。我们相比较String对象的存储，就可以知道，StringBuffer对象在此处并不符合栈上分配的条件（ 将线程私有的对象打散分配在栈上，可以在函数调用结束后自行销毁对象，不需要垃圾回收器的介入，有效避免垃圾回收带来的负面影响，栈上分配速度快，提高系统性能），所以我们可以知道，StringBuffer的append方法并不会在堆上创建新的StringBuffer对象且内容是结果字符串，而是在arraycopy方法的帮助下，将各个字符引用连接起来。

结论：StringBuffer是一个可变类。