StringBuffer与StringBuilder源代码分析
背景想了解StringBuffer与StringBuilder之间的差别以及他们是通过何种方式去实现其功能的。差别大致了解，线程安全与不安全。更感兴趣的是其实现方式。AbstractStringBuilder两者都继承自此抽象类。该类提供了一些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的代码就不贴了。
