StringBuilder是一个可变字符序列 (字符串)。和String相比，两者都是字符串，都是字符的有序排列；不同的是，String是不可变的，而StringBuilder是可变的。
StringBuilder和StringBuffer几乎一样，只是前者没有同步处理，更加高效。因此，这两者的操作逻辑几乎是一样的，可以通过一个抽象的父类AbstractStringBuilder来实现共同的方法，而只需要在StringBuffer的方法中加上synchronized关键字即可。这点可以在源码中明显感觉到。
所以这里就不讨论StringBuffer了，只看StringBuilder，下面将结合AbstractStringBuilder一起来讨论StringBuilder的应用。
StringBuffer主要就是几个修改字符串的方法：append(),insert(),delete()。
有序字符串
StringBuilder和String一样都是字符串，所以用同样的方式来存储字符：char数组。也是使用value和count属性来表示：
char[]value; int count;
StringBuilder默认新建的长度为16，如果有初始化的String，就再加16，相当于预留16的可变长度。
public StringBuilder() {
super(16);
}
public StringBuilder(String str) {
super(str.length() +16);
append(str);
}
这里调用了AbstractStringBuilder的构造函数，相当于初始化了一个长度为16的char数组，然后调用append来把初始化的String赋值进去。
AbstractStringBuilder(int capacity) {
value =newchar[capacity];
}
append
接下来，我们看看StringBuilder.append()，这里添加完之后，返回自身this，这样可以连续的调用，很方便，如【sb.append("Hello").append("World")】
public StringBuilder append(Stringstr) {
super.append(str);
returnthis;
}
这里实质上调用了AbstractStringBuilder.append()，如下：
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;
returnthis;
}
public void getChars(int srcBegin,int srcEnd,char dst[],int dstBegin) {
// ……此处省略String的范围判断
System.arraycopy(value,offset + srcBegin, dst,dstBegin,srcEnd - srcBegin);
}
从上面可以看出来，append()是在char数组的末尾添加：首先校验value的长度；然后再把String的char数组追加到value后面。
通过ensureCapacityInternal()校验value的长度，溢出则调用expandCapacity()来扩展。 扩展逻辑：每次扩充原来产度的(len+1)*2，上限为Integer.MAX_VALUE，下限为追加后长度minimumCapacity。
可以看出如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。这个操作是比较耗性能的，要尽量避免，所以在创建StringBufferd时候要指定好容量，多预留一些空间。 同理Collection
void expandCapacity(int minimumCapacity) {
int newCapacity =value.length * 2 + 2;
if (newCapacity - minimumCapacity < 0)
newCapacity = minimumCapacity;
if (newCapacity < 0) {
if (minimumCapacity < 0) // overflow
thrownew OutOfMemoryError();
newCapacity = Integer.MAX_VALUE;
}
value = Arrays.copyOf(value, newCapacity); // 往后扩充数组
}
public staticchar[] copyOf(char[] original,int newLength) {
char[] copy =new char[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
上面讨论完了append(String)，这是最常用的情况。
如果只有一个字符的时候，不要用append(String)，而要用append(char)，逻辑更简单高效，直接在后面追加一个字符即可，不用再依赖String的属性。这也是FindBugs所提倡的用法。
public AbstractStringBuilder append(char c) {
ensureCapacityInternal(count + 1);
value[count++] = c;
returnthis;
}
insert
append()是在尾部追加，而想要中间插入的话，可以通过insert()，从下面代码能看出来，和append()的逻辑不同的，只是在数组copy的时候，把value从offset处分开，留一个insertStr的长度的空位，把insertStr插入：【str.getChars(value,offset)】
public StringBuilder insert(int offset, Stringstr) {
super.insert(offset, str);
returnthis;
}
public AbstractStringBuilder insert(int offset, Stringstr) {
if ((offset < 0) || (offset > length()))
thrownew StringIndexOutOfBoundsException(offset);
if (str ==null)
str = "null";
int len = str.length();
ensureCapacityInternal(count + len);
System.arraycopy(value, offset,value, offset + len,count - offset);
str.getChars(value, offset); //往空挡插入
count += len;
returnthis;
}
delete
使用delete()可以自由地删除中间的字串。如下所示，实际上就是把end后的字串覆盖到start的位置上，然后把count相应缩小，后面的没有覆盖的部分就自然无效了。
public StringBuilder delete(int start,int end) {
super.delete(start, end);
returnthis;
}
public AbstractStringBuilder delete(int start,int end) {
if (start < 0)
thrownew StringIndexOutOfBoundsException(start);
if (end >count)
end = count;
if (start > end)
thrownew StringIndexOutOfBoundsException();
int len = end - start;
if (len > 0) { // 把end后的字串覆盖到start后
System.arraycopy(value, start+len,value, start, count-end);
count -= len; // 相应缩小count
}
returnthis;
}