StringBuilder是我们常用来动态拼接字符串的一个类,通常在面试中被问到这个可能就离不开这个问题“String、StringBuffer和StringBuilder的区别?”。这个问题也是老生常谈的,相信大家都不陌生。一个最明显的区别就是String是不可变的,在动态拼接字符串时会产生很多新的对象,StringBuffer和StringBuilder就是用来解决这个问题的,它们继承了 AbstractStringBuilder ,底层基于可修改的char数组(JDK8),而这两个的区别是StringBuffer加了synchronized关键字,是线程安全的,而StringBuilder是非线程安全的。

知道它们的区别,那么StringBuilder的底层到底是如何实现修改的呢?分析部分源码如下:

1、StringBuilder的结构
public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence{
	....
}

~~~~~~~~~~~~~~~~~~~~~~~萌萌哒分割线~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

可以看到StringBuilder继承自AbstractStringBuilder,底层有一个char数组存放字符,count记录字符个数。

2、创建StringBuilder对象,看下它的构造函数
	/**
     * 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);
    }
    /**
     * Creates an AbstractStringBuilder of the specified capacity.
     */
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }
3、再看下StringBuilder的拼接方法append,部分源码如下:
	@Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

~~~~~~~~~~~~~~~~~萌萌哒分割线~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	父类AbstractStringBuilder的appeng方法实现:
	
	/**
     * Appends the specified string to this character sequence.
     * <p>
     * The characters of the {@code String} argument are appended, in
     * order, increasing the length of this sequence by the length of the
     * argument. If {@code str} is {@code null}, then the four
     * characters {@code "null"} are appended.
     * <p>
     * Let <i>n</i> be the length of this character sequence just prior to
     * execution of the {@code append} method. Then the character at
     * index <i>k</i> in the new character sequence is equal to the character
     * at index <i>k</i> in the old character sequence, if <i>k</i> is less
     * than <i>n</i>; otherwise, it is equal to the character at index
     * <i>k-n</i> in the argument {@code str}.
     *
     * @param   str   a string.
     * @return  a reference to this object.
     */
    public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();//@1
        int len = str.length();//@2
        ensureCapacityInternal(count + len);//@3
        str.getChars(0, len, value, count);//@4
        count += len;@5
        return this;//@6
    }

逐个分析上面的@1~@6,看看具体每步做了什么。
@1:appentNull()

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

@2:int len = str.length();待添加的字符串长度
@3:ensureCapacityInternal(count + len);将当前char数组中字符个数加上待添加的字符串长度,也调用的这个方法和拼接null时一样,只不过拼接null时待添加的字符串长度等于4,看下这个方法做了什么

/**
     * For positive values of {@code minimumCapacity}, this method
     * behaves like {@code ensureCapacity}, however it is never
     * synchronized.
     * If {@code minimumCapacity} is non positive due to numeric
     * overflow, this method throws {@code OutOfMemoryError}.
     */
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }

看代码结合方法注释就很清楚,就是将字符总数和char数组的长度比对,确保char数组长度是否足够,如果不够就需要扩容,copy一个新的数组,将旧数组的数据复制到新数组中,然后将引用赋值给value,同时这里newCapacity里面对于新数组的长度也有一些判断逻辑,源码如下:

    /**
     * Returns a capacity at least as large as the given minimum capacity.
     * Returns the current capacity increased by the same amount + 2 if
     * that suffices.
     * Will not return a capacity greater than {@code MAX_ARRAY_SIZE}
     * unless the given minimum capacity is greater than that.
     *
     * @param  minCapacity the desired minimum capacity
     * @throws OutOfMemoryError if minCapacity is less than zero or
     *         greater than Integer.MAX_VALUE
     */
    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;
    }

@4:str.getChars(0, len, value, count);将待添加的字符添加到char数组
@5:count += len;将count记录的字符个数加上新加的
@6:return this;返回当前对象

4、总结

通过上面的分析总结下StringBuilder的底层实现原理:
(1)new StringBuilder()默认创建一个容量大小=16的char数组
(2)调用append方法拼接字符串首先会判断char数组容量是否组足够,如果不够需要扩容,按原来数组大小的2倍+2扩容,将原来char数组的元素赋值到新扩容的数组中,并将新数组引用赋值给原来的value,
(3)将待拼接的字符也添加到新数组中,将记录字符个数的count更新
(4)返回当前对象

分析StringBuilder其他更多的方法会发现每次操作返回的都是当前对象,这也是为什么在动态拼接字符串的时候推荐使用它而非String的原因。另一个点就是由于 StringBuilder 底层是基于 char 数组存放字符,而数组是连续内存结构,为了防止频繁地复制和申请内存,在预先知道字符串大概长度的情况下,new StringBuilder()时可以先指定capacity的值,减少数组的扩容次数提高效率。

12-05 16:17