StringBuilder和StringBuffer的区别

StringBuilder和StringBuffer都实现了继承了AbstractStringBuilder(核心类，对char[]进行操作)，实现了Serializable接口(支持序列化和反序列化)和CharSequence(主要定义了length、charAt、subSquence方法)

StringBuilder和StringBuffer主要不同在于，StringBuffer的append、delete、replace、length等方法前都加了synchronized关键字保证线程安全，而StringBuilder没有，另外的区别在于StringBuffer有一个toStringCache的char数组，是用于记录最近一次toString()方法的缓存，任何时候只要StringBuffer被修改了这个变量会被赋值为null

以StringBuilder为例
比如有以下Java代码

        StringBuilder stringBuilder=new StringBuilder();
        stringBuilder.append("11");
        stringBuilder.delete(0,2);
        System.out.println(stringBuilder.toString());

首先 StringBuilder stringBuilder=new StringBuilder();
然后看StringBuilder的构造方法，
这里调用默认构造方法，默认容量为16

然后进入到AbstractStringBuilder，new了一个容量为capacity的char数组

然后执行 stringBuilder.append(“11”);

进入到AbstractStringBuilder里

    public AbstractStringBuilder append(String str) {
        if (str == null)//当要添加的字符串为空时候，执行添加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) {//最小容量大于当前容量
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));//扩容后新数组
        }
    }

这是我们进入到
newCapacity方法里面

minimumCapacity为16+2=18，
value.length=16

    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int newCapacity = (value.length << 1) + 2;//新容量为2*当前容量+2也就是34
        if (newCapacity - minCapacity < 0) {//如果新容量小于所需的最小容量，新容量设置为最小容量
            newCapacity = minCapacity;
        }
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;//越界检查，不越界就返回新容量
    }

然后执行stringBuilder.delete(0,2);

    @Override
    public StringBuilder delete(int start, int end) {
        super.delete(start, end);
        return this;
    }

进入到AbstractStringBuilder

    public AbstractStringBuilder delete(int start, int end) {
        if (start < 0)//开始下标<0,抛下标越界异常
            throw new StringIndexOutOfBoundsException(start);
        if (end > count)//结束下标>当前数组下标，不会抛异常，会设置结束下标为数组长度
            end = count;
        if (start > end)//开始下标>结束下标,抛下标越界异常
            throw new StringIndexOutOfBoundsException();
        int len = end - start;//计算长度
        if (len > 0) {
            System.arraycopy(value, start+len, value, start, count-end);//删除下标>=start且<=end之间的元素
            count -= len;//当前数组长度-len
        }
        return this;
    }

然后看arraycopy实现，发现为native方法，底层由c++实现

    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);