Java_可变字符串_StringBulider源码分析

上文，我们已经知道，String是不可变字符序列。每个字符串的操作，都会新生成一个对象，如果涉及频繁的字符串操作，这样下去，会非常耗费资源。
这样，我们就需要一个可变字符序列。是不是需要写一个，没必要，Jdk都替我们写好了，StringBulider就是可变字符序列。那它又是怎么实现的呀，还是数组吗？数组可是初始化后，就不能改变了呀，好奇。

打开源码，找答案吧。

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{

    // 默认长度是16
    public StringBuilder() {
        super(16);
    }

   // 如果有字符串 默认长度是字符串长度+16
   public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }

通过代码，我们可以看出，StringBulider继承了一个抽象类AbstractStringBuilder，继续打开源码：

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char[] value;

   /**
     * Creates an AbstractStringBuilder of the specified capacity.
     */
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

居然又是又数组，更加好奇了，不过也可以看出，StringBulider与String还是有差别的，至少这个数组是可以赋值的，玄机在这里吗？字符串长度增加的时候，需要变长，我们看一下append函数吧。

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

    public AbstractStringBuilder append(String str) {
        if (str == null) str = "null";
        int len = str.length();
        // 传入新字符串的长度，计算是否需要扩容
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }

    /**
     * This method has the same contract as ensureCapacity, but is
     * never synchronized.
     */
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        // 长度不够，需要扩容
        if (minimumCapacity - value.length > 0)
            expandCapacity(minimumCapacity);
    }

    /**
     * This implements the expansion semantics of ensureCapacity with no
     * size check or synchronization.
     */
    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);
    }

通过看源码，我们可以清楚的了解StringBulider的实现方法：还是用数组实现的，就是长度不足的时候，新建一个更长的数组，实现变长，原来是这样。