01-StringBuilder 源码分析

public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append((String) null);
        sb.append("1234567890");

StringBuilder 源码分析 jdk 1.8

• StringBuilder sb = new StringBuilder();源码

// 源码
public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
    /**
     * string builder 构造器，设置初始容量为16
     */
    public StringBuilder() {
        super(16);
    }
}
// super 指向 抽象类AbstractStringBuilder
abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
    * 底层为char数组
    */
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }
}

• sb.append("1234567890"); 源码

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
}
// super.append 指向 抽象类AbstractStringBuilder
abstract class AbstractStringBuilder implements Appendable, CharSequence {
    // StringBuilder 的长度
    int count;

    // 底层为char数组
    char[] value;

    public AbstractStringBuilder append(String str) {
        // 判断字符串是否为空
        if (str == null)
            // 调用appendNull方法
            return appendNull();
        // 获取字符串长度
        int len = str.length();
        // 确认容量 - 设置char数组容量
        ensureCapacityInternal(count + len);
        // 将字符串的char数组拷贝到当前char数组
        /*
        Params:
            0 – 开始索引
            len – 结束索引
            value – 即将更新的char数组
            count – 即将更新的char数组的起始索引
        */
        str.getChars(0, len, value, count);
        // StringBuilder的长度
        count += len;
        return this;
    }


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

    // minimumCapacity 为即将添加的char数组长度
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        // 判断是否超过char数组长度
        // value.length 是当前char数组长度
        if (minimumCapacity - value.length > 0) {
            // 即将添加的字符串长度大于当前char数组长度
            // Arrays.copyOf 是拷贝新的char数组，参数为【原数组，新数组长度】
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }

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

    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        // 设置新的char数组容量:【当前char数组长度 * 2 + 2】
        int newCapacity = (value.length << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            // 如果新的char数组容量 < 即将添加的char数组长度，则容量 = 即将添加的char数组长度
            newCapacity = minCapacity;
        }
        // 判断容量是否超过最大值：超过就调用hugeCapacity方法
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }

    private int hugeCapacity(int minCapacity) {
        if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
            // 如果即将添加的char数组容量超过最大值，抛出内存溢出异常
            throw new OutOfMemoryError();
        }
        // 判断即将添加的char数组容量 > MAX_ARRAY_SIZE
        return (minCapacity > MAX_ARRAY_SIZE)
            ? minCapacity : MAX_ARRAY_SIZE;
    }
}

总结

StringBuilder 是一个可变的字符序列，容量默认为 16，当容量不够时，会扩容为【当前容量 * 2 + 2】。