StringBuilder 和 StringBuffer
StringBuilder 和 StringBuffer 都继承了 AbstractStringBuilder 类，所有实际的字符操作都在父类实现，
主要的区别是 StringBuilder 只是简单的调用父类方法，而 StringBuffer 的写操作都添加了 synchronized 关键字。
StringBuffer 是线程安全的，而 StringBuilder 不是线程安全的。
AbstractStringBuilder
/**
* 可变的字符序列
*
* @author Michael McCloskey
* @author Martin Buchholz
* @author Ulf Zibis
* @since 1.5
*/
abstract class AbstractStringBuilder implements Appendable, CharSequence {
/**
* 用于字符存储的字节数组
*/
byte[] value;
/**
* 编码器
*/
byte coder;
/**
* 字符总数
*/
int count;
/**
* 往可变字符序列中追加 boolean 值
*
* @param b 一个 boolean 值
*/
public AbstractStringBuilder append(boolean b) {
// 尝试进行扩容
ensureCapacityInternal(count + (b ? 4 : 5));
// 读取当前字符数到局部变量表
int count = this.count;
// 读取字节数组到局部变量表
final byte[] val = value;
// 1）如果是 LATIN1 编码
if (isLatin1()) {
// 追加字符
if (b) {
val[count++] = 't';
val[count++] = 'r';
val[count++] = 'u';
val[count++] = 'e';
} else {
val[count++] = 'f';
val[count++] = 'a';
val[count++] = 'l';
val[count++] = 's';
val[count++] = 'e';
}
// 2）如果是 UTF16 编码
} else {
if (b) {
count = StringUTF16.putCharsAt(val, count, 't', 'r', 'u', 'e');
} else {
count = StringUTF16.putCharsAt(val, count, 'f', 'a', 'l', 's', 'e');
}
}
this.count = count;
return this;
}
/**
* 往可变字符序列中追加单个字符
*
* @param c 单个字符
*/
@Override
public AbstractStringBuilder append(char c) {
ensureCapacityInternal(count + 1);
if (isLatin1() && StringLatin1.canEncode(c)) {
value[count++] = (byte)c;
} else {
if (isLatin1()) {
inflate();
}
StringUTF16.putCharSB(value, count++, c);
}
return this;
}
/**
* 往可变字符序列中追加 int 值
*
* @param i 一个 int 值
*/
public AbstractStringBuilder append(int i) {
final int count = this.count;
final int spaceNeeded = count + Integer.stringSize(i);
ensureCapacityInternal(spaceNeeded);
if (isLatin1()) {
Integer.getChars(i, spaceNeeded, value);
} else {
StringUTF16.getChars(i, count, spaceNeeded, value);
}
this.count = spaceNeeded;
return this;
}
/**
* 往可变字符序列中追加 long 值
*
* @param l 一个 long 值
*/
public AbstractStringBuilder append(long l) {
final int count = this.count;
final int spaceNeeded = count + Long.stringSize(l);
ensureCapacityInternal(spaceNeeded);
if (isLatin1()) {
Long.getChars(l, spaceNeeded, value);
} else {
StringUTF16.getChars(l, count, spaceNeeded, value);
}
this.count = spaceNeeded;
return this;
}
/**
* 往可变字符序列中追加 float 值
*
* @param f 一个浮点值
*/
public AbstractStringBuilder append(float f) {
FloatingDecimal.appendTo(f,this);
return this;
}
/**
* 往可变字符序列中追加 double 值
*
* @param d 一个 double 值
*/
public AbstractStringBuilder append(double d) {
FloatingDecimal.appendTo(d,this);
return this;
}
/**
* 往可变字符序列中追加对象
*
* @param obj 一个对象
*/
public AbstractStringBuilder append(Object obj) {
return append(String.valueOf(obj));
}
/**
* 往可变字符序列中追加字符串
*
* @param str 一个字符串
*/
public AbstractStringBuilder append(String str) {
if (str == null) {
return appendNull();
}
final int len = str.length();
ensureCapacityInternal(count + len);
putStringAt(count, str);
count += len;
return this;
}
/**
* 往可变字符序列中追加字符数组
*
* @param str 字符数组
*/
public AbstractStringBuilder append(char[] str) {
final int len = str.length;
ensureCapacityInternal(count + len);
appendChars(str, 0, len);
return this;
}
/**
* 往可变字符序列中追加字符序列
*
* @param s 目标字符序列
*/
@Override
public AbstractStringBuilder append(CharSequence s) {
if (s == null) {
return appendNull();
}
if (s instanceof String) {
return this.append((String)s);
}
if (s instanceof AbstractStringBuilder) {
return this.append((AbstractStringBuilder)s);
}
return this.append(s, 0, s.length());
}
/**
* 尝试进行扩容
*/
private void ensureCapacityInternal(int minimumCapacity) {
// 读取旧容量 overflow-conscious code
final int oldCapacity = value.length >> coder;
// 所需最小容量 > 旧容量
if (minimumCapacity - oldCapacity > 0) {
// 扩容并拷贝源字节数组
value = Arrays.copyOf(value,
newCapacity(minimumCapacity) << coder);
}
}
/**
* 返回大于 minCapacity 的最小容量值
*
* @param minCapacity 期望的最小容量
*/
private int newCapacity(int minCapacity) {
// overflow-conscious code
final int oldCapacity = value.length >> coder;
// 双倍扩容 + 2
int newCapacity = (oldCapacity << 1) + 2;
// 扩容后新容量还是 < 期望最小容量，则使用期望最小容量
if (newCapacity - minCapacity < 0) {
newCapacity = minCapacity;
}
final int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
// 一般不会走 hugeCapacity
return newCapacity <= 0 || SAFE_BOUND - newCapacity < 0 ? hugeCapacity(minCapacity) : newCapacity;
}
private int hugeCapacity(int minCapacity) {
final int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
final int UNSAFE_BOUND = Integer.MAX_VALUE >> coder;
if (UNSAFE_BOUND - minCapacity < 0) { // overflow
throw new OutOfMemoryError();
}
return minCapacity > SAFE_BOUND
? minCapacity : SAFE_BOUND;
}
/**
* 在目标索引处插入 boolean 值
*
* @param offset 目标索引
* @param b 一个 boolean 值
*/
public AbstractStringBuilder insert(int offset, boolean b) {
return insert(offset, String.valueOf(b));
}
/**
* 在目标索引 offset 处插入字符串。
*
* @param offset 目标索引
* @param str 字符串
*/
public AbstractStringBuilder insert(int offset, String str) {
// 校验索引的合法性
checkOffset(offset, count);
// 目标字符为 null，则插入 'null'
if (str == null) {
str = "null";
}
// 计算目标字符长度
final int len = str.length();
// 尝试扩容
ensureCapacityInternal(count + len);
// 目标索引处及其之后的字符数组集体右移 len 个位置
shift(offset, len);
count += len;
// 插入目标字符串到指定索引 offset 处
putStringAt(offset, str);
return this;
}
/**
* 通过数组拷贝完成子数组迁移
*
* @param offset 目标索引
* @param n
*/
private void shift(int offset, int n) {
System.arraycopy(value, offset << coder,
value, offset + n << coder, count - offset << coder);
}
/**
* 删除目标索引 start 和 end 之间的所有字符，包括起始不包括结束
*
* @param start 起始索引，包含
* @param end 结束索引，不包含
*/
public AbstractStringBuilder delete(int start, int end) {
// 从堆内存加载数据到栈局部变量表
final int count = this.count;
if (end > count) {
end = count;
}
checkRangeSIOOBE(start, end, count);
final int len = end - start;
if (len > 0) {
// 从 start 索引处开始的子字符数组集体左移 len 个位置
shift(end, -len);
this.count = count - len;
}
return this;
}
/**
* 删除指定索引 index 处的单个字符
*
* @param index 待移除字符的索引
*/
public AbstractStringBuilder deleteCharAt(int index) {
checkIndex(index, count);
shift(index + 1, -1);
count--;
return this;
}
/**
* 截取起始索引 start 到结束索引 end 之间的子字符串
*
* @param start 起始索引，包括
* @param end 结束索引，不包括
*/
@Override
public CharSequence subSequence(int start, int end) {
return substring(start, end);
}
/**
* 截取起始索引 start 到结束索引 end 之间的子字符串
*
* @param start 起始索引，包括
* @param end 结束索引，不包括
*/
public String substring(int start, int end) {
checkRangeSIOOBE(start, end, count);
if (isLatin1()) {
return StringLatin1.newString(value, start, end - start);
}
return StringUTF16.newString(value, start, end - start);
}
/**
* 从起始索引 start 开始，截取剩余的子字符串
*
* @param start 起始索引，包括
*/
public String substring(int start) {
return substring(start, count);
}