我们知道，在java中，如果要对于一个字符串进行操作，比如增删操作，如果直接用+来进行的话，效率是比较低的。作为替代，我们一般使用StringBuilder来进行这样的操作。

所以，这一次，我们就来研究一下StringBuilder的源码

构造函数

public final class StringBuilder    extends AbstractStringBuilder    implements java.io.Serializable, CharSequence{
        /** use serialVersionUID for interoperability */    static final long serialVersionUID = 4383685877147921099L;    /**     * Constructs a string builder with no characters in it and an     * initial capacity of 16 characters.     */    public StringBuilder() {
            super(16);    }    /**     * Constructs a string builder with no characters in it and an     * initial capacity specified by the {@code capacity} argument.     *     * @param      capacity  the initial capacity.     * @throws     NegativeArraySizeException  if the {@code capacity}     *               argument is less than {@code 0}.     */    public StringBuilder(int capacity) {
            super(capacity);    }    /**     * Constructs a string builder initialized to the contents of the     * specified string. The initial capacity of the string builder is     * {@code 16} plus the length of the string argument.     *     * @param   str   the initial contents of the buffer.     */    public StringBuilder(String str) {
            super(str.length() + 16);        append(str);    }    /**     * Constructs a string builder that contains the same characters     * as the specified {@code CharSequence}. The initial capacity of     * the string builder is {@code 16} plus the length of the     * {@code CharSequence} argument.     *     * @param      seq   the sequence to copy.     */    public StringBuilder(CharSequence seq) {
            this(seq.length() + 16);        append(seq);    }    ...}

可以看到，当我们不指定初始的容量的时候，会调用父类AbstractStringBuilder的构造函数，并默认初始容量为16。

所以，我们来看看’AbstractStringBuilder’的构造方法：

abstract class AbstractStringBuilder implements Appendable, CharSequence {    /**     * The value is used for character storage.     */    char[] value;    /**     * The count is the number of characters used.     */    int count;    /**     * This no-arg constructor is necessary for serialization of subclasses.     */    AbstractStringBuilder() {    }    /**     * Creates an AbstractStringBuilder of the specified capacity.     */    AbstractStringBuilder(int capacity) {        value = new char[capacity];    }    ...}

其中，主要关注：

AbstractStringBuilder(int capacity) {
            value = new char[capacity];    }

可以看到，在这里根据设定的初始容量，初始化出了一个相应长度的char型数组value。

append方法

这里以str的append方法为例，看一下StringBuilder的append方法是怎样工作的。

首先是StringBuilder中的append(String str)方法。

public StringBuilder append(String str) {
        super.append(str);    return this;}

指向了父类中的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;}

其中的ensureCapacityInternal是为了保证容量能够装得下这个输入的str。

private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code    if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,                newCapacity(minimumCapacity));    }}private int newCapacity(int minCapacity) {
        // overflow-conscious code    int newCapacity = (value.length << 1) + 2;    if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;    }    return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)        ? hugeCapacity(minCapacity)        : newCapacity;}private int hugeCapacity(int minCapacity) {
        if (Integer.MAX_VALUE - minCapacity < 0) {
     // overflow        throw new OutOfMemoryError();    }    return (minCapacity > MAX_ARRAY_SIZE)        ? minCapacity : MAX_ARRAY_SIZE;}

这里的扩容方式为先将容量乘2再加2，再与所需容量进行比较，若小于所需容量，则取所需容量，后面还有防止溢出的操作，写得非常严谨，这里值得我们学习与借鉴。获得更新后的容量后，新建一个新的容量的数组，并将之前的数据用Arrays.copyOf()方法复制进去，并更新为新的成员变量value。

我们回到append方法中来，在进行完ensureCapacityInternal后，就要将所需添加的数据加进来了，这里调用的是String的getChars方法。

# String.javapublic 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);}

这里调用System.arraycopy来将String内部的成员变量char型数组value(注意这里是String的，也就是append的参数里的那个变量)从0到str.length()，也就是所有成员，复制到dst中，也就是StringBuilder的成员变量value中。之后，便完成了整个append的操作。