StringBuilder和StringBuffer源码解读

简介

StringBuiler是一个非常常用的操作字符串的额类，同样的还有一个StringBuiler，两个类很多相似，不同是StringBuiler是线程安全的，而StringBuffer是线程不安全的，这篇文章我们就先来好好学习下StringBuiler的源码

继承关系

继承关系

从上图可以看见，StringBuiler继承AbstractStringBuilder这个类，这是一个抽象类，但是包含了很多char[]的操作方法，StringBuiler的append方法和扩容方法都是从这个抽象类继承过来的，封装了大部分StringBuiler操作的实现。同时StringBuiler还直接实现了Serializable和CharSequence接口，用于序列化和实现了charAt()、length()、subSequence()、toString()等方法。

变量及构造方法

StringBuiler从AbstractStringBuilder继承了value和count两个变量

    /**
     * 用于存储字符串的字符数组
     */
    char[] value;

    /**
     * 已经使用的字符数
     */
    int count;

同时还提供了四个构造方法

    /**
     * 无参构造函数
     */
    public StringBuilder() {
        //调用父类的构造函数
        super(16);
    }

    /**
     * 指定容量的构造函数，但是没有字符内容
     * @param      capacity  初始化的容量.
     */
    public StringBuilder(int capacity) {
        super(capacity);
    }

    /**
     * 构造一个初始化为指定字符串内容的sb。sb的初始容量是16加上字符串参数的长度。
     *
     * @param   str   初始化的内容.
     */
    public StringBuilder(String str) {
        //长度为指定字符串的长度+16
        super(str.length() + 16);
        //调用append函数，将内容加上去
        append(str);
    }

    /**
     * 构造一个包含与指定CharSequence相同字符的字符串生成器。字符串生成器的初始容量为16加上CharSequence参数的长度。
     *
     * @param      seq   复制的序列.
     */
    public StringBuilder(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }

扩容方法

从上面的构造函数我们可以看出，一般StringBuiler初始化的时候是指定了字符数组的长度的，没有指定时默认就是16，所以可想而知肯定需要一定的扩容机制来满足我们的append()方法，那我们就先来看看StringBuiler的扩容机制，直接在下面的代码中注释了

    // 这是每次要新添加元素时都需要执行的方法，因为需要确认当前容量是否允许插入要插入的字符
    private void ensureCapacityInternal(int minimumCapacity) {
        // 超出了容量，这时候就需要进行扩容了
        if (minimumCapacity - value.length > 0) {
            // newCapacity方法用来扩容的方法
            value = Arrays.copyOf(value, newCapacity(minimumCapacity));
        }
    }

接下来我们看看扩容方法newCapacity具体是如何实现的

    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        // 先将原来的容量*2然后再加2定为新的容量
        int newCapacity = (value.length << 1) + 2;
        // 如果刚刚的新容量还比需要的最小容量小的话，那直接把需要的最小的容量设为新的容量
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        // 如果新的容量小于或等于零（这是考虑出错的情况）或者新的容量比约定的最大容量还大的话则进入方法hugeCapacity，否则返回newCapacity，扩容成功
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }

接下里我们来看看hugeCapacity是如何实现的

    private int hugeCapacity(int minCapacity) {
        // 如果需要的最小容量大于Integer.MAX_VALUE的话，就报内存溢出错误
        if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
            throw new OutOfMemoryError();
        }
        //如果需要的新容量大于MAX_ARRAY_SIZE则返回新容量，否则返回MAX_ARRAY_SIZE;
        return (minCapacity > MAX_ARRAY_SIZE)
            ? minCapacity : MAX_ARRAY_SIZE;
    }

append方法

前面我们学习完了扩容机制之后我们接下来学习一下最重要的append方法

append

从上图中我们可以看到，为了适用不同的类型，AbstracStringBuilder为我们提供了多个append的方法的重载方法，下面我们一起来看看他们的代码实现

    // 这是添加字符串时的append方法
    public AbstractStringBuilder append(String str) {
        //如果字符串为空，则进入appendNull方法，我们等下去看
        if (str == null)
            return appendNull();
        int len = str.length();
        //先调用我们前面分析过的扩容方法保证容量大小能够
        ensureCapacityInternal(count + len);
        //调用String的getchars方法进行添加，其实最后都是调用了System.arraycopy方法
        str.getChars(0, len, value, count);
        //记录已经使用的容量
        count += len;
        return this;
    }

我们来看看appendNull方法

    //其实如果要添加的对象是null的话，就直接添加“null”在最后，然后源码其实很简单，很容易看懂
    private AbstractStringBuilder appendNull() {
        int c = count;
        ensureCapacityInternal(c + 4);
        final char[] value = this.value;
        value[c++] = 'n';
        value[c++] = 'u';
        value[c++] = 'l';
        value[c++] = 'l';
        count = c;
        return this;
    }

然后其实其他的append方法实现也很简单，这里就不一一贴出来了
然后其他的方法其实也很简单，我们把主要的append方法和扩容机制学习弄懂之后就差不多了，其他的直接照着源码读就好了

总结

最后我们来总结一下，其实大家接下来去看看StringBuffer的源码会发现其实它的源码和StringBuilder的源码很相似，都是继承于AbstractStringBuilder，只不过为了能够在多线程的情况下能够安全工作，StringBuffer的大部分方法都加了关键字synchronized,以用来加锁，实现线程安全。
同样的，如果在单线程的工作环境下我们应该使用StringBuilder，因为StringBuffer的加锁和释放锁要消耗系统资源和时间，所以效率没有StringBuilder高
再提一下扩容机制，从前面的源码解读我们可以发现，其实它们的扩容机制很简单，就是将原来的capacity * 2 + 2，然后跟我们需要的capacity比较，如果可以就可以，还不够的话就进行hugeCapacity方法，最大的容量是MAX_ARRAY_SIZE

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;