StringBuffer与StringBuilder源代码分析

背景

想了解StringBuffer与StringBuilder之间的差别以及他们是通过何种方式去实现其功能的。差别大致了解，线程安全与不安全。更感兴趣的是其实现方式。

AbstractStringBuilder

两者都继承自此抽象类。该类提供了一些StringBuffer与StringBuilder公用的方法。

StringBuffer

public StringBuffer() {
  super(16);
}

public StringBuffer(int capacity) {
  super(capacity);
}

public StringBuffer(String str) {
  super(str.length() + 16);
  append(str);
}

public StringBuffer(CharSequence seq) {
  this(seq.length() + 16);
  append(seq);
}

一般常用到的两个构造函数为第一、三个。从上面来看，其默认的长度为16。这个16是一个什么的值呢，查看其super，如下：

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

其背后的实现只是一个char[]，没有其他了吗？回头继续往下看其如何进行append()，由于该方法有很多个重载方法，因此选择一个经常用的其参数为String的来看，如下：

// StringBuffer.java
@Override
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}
// AbstractStringBuilder.java
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;
}

其中count为当前StringBuffer中已存在的字符数，len为当前String的长度。很显然ensureCapacityInternal(count + len);是为了不让之前的字符数组溢出。获取这算是其核心之一吧，很值得去看看。如下：

// AbstractStringBuilder.java
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 static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private int hugeCapacity(int minCapacity) {
    if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
        throw new OutOfMemoryError();
    }
    return (minCapacity > MAX_ARRAY_SIZE)
        ? minCapacity : MAX_ARRAY_SIZE;
}

// Integer.java
public static final int   MAX_VALUE = 0x7fffffff;

// Arrays.java
public static char[] copyOf(char[] original, int newLength) {
    char[] copy = new char[newLength];
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}
// 再往下就是native方法了
public static native void arraycopy(
	Object src,  int  srcPos, Object dest, int destPos,int length);

也就是说，每次append都会返回一个新的包含此前char[]中数据的char[]数组，此时的数组长度已经被x2+2。

然后调用String的getChars(int srcBegin, int srcEnd, char dst[], int dstBegin)方法，将此字符串，添加到目标数组中。在此有个困惑，每次返回来的数组长度已经变了，可是在StringBuffer中调用capacity()方法显示长度只是变成了添加了字符串之后的长度。是因为那个native方法吗？应该是吧。

线程安全

这大概就是append的过程了。仔细想想，如果是这样操作的话，多线程的环境下可能会出现一些问题。因此，大部分的StringBuffer中的方法都加上了synchronized关键字，因此它就是线程安全的了。在看StringBuilder，没有。其操作基本上是使用AbstractStringBuilder类的方法。在两者的对应方法中，只是加了/没加同步关键字的差别吧。StringBuilder的代码就不贴了。