StringBuffer是一个线程安全的、可变的字符序列。
它和String类似，只不过是可以改变的。StringBuffer通过指定的方法改变内部的字符串序列。
StringBuffer是线程安全的，大部分方法在声明的时候加了Synchronized关键字， 这些方法在必要时进行同步，以便在任何特定实例上进行的所有操作都表现为好像以某种串行顺序进行，该顺序与所涉及的每个单独线程进行的方法调用的顺序一致。
从源码来看StringBuffer的属性和方法的具体作用：
StringBuffer继承了抽象类AbstractStringBuilder，并且实现了系列化接口以及字符序列接口：
public final class StringBuffer
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{
//相当于最后返回的String的一个缓存字符数组，每次modified后都会做相应的更新。
private transient char[] toStringCache;
//几个构造方法，无参时默认capacity为16
public StringBuffer() {
super(16);
}
//指定capacity
public StringBuffer(int capacity) {
super(capacity);
}
//初始化时指定字符串，capacity为字符串长度+16
public StringBuffer(String str) {
super(str.length() + 16);
append(str);
}
//CharSequence是一个接口，多个类例如StringBuffer都实现了它
public StringBuffer(CharSequence seq) {
this(seq.length() + 16);
append(seq);
}
//length与capacity的区别是：前者字符串长度，后者为数组的容量
@Override
public synchronized int length() {
return count;
}
@Override
public synchronized int capacity() {
return value.length;
}
//改变capacity的值，如果构造StringBuffer时没有指定capacity(默认16)且没有扩容操作，那么：
//1.ensureCapacity时minimumCapacity < 34,新扩容capacity的值为34；
//2.ensureCapacity时minimumCapacity > 34,新扩容的值为minimumCapacity。
//（具体看AbstractStringBuffer源码）
@Override
public synchronized void ensureCapacity(int minimumCapacity) {
super.ensureCapacity(minimumCapacity);
}
//设置length的值，大于字符串本身长度的部分填充为null（ASCII码中的‘0’）
@Override
public synchronized void setLength(int newLength) {
toStringCache = null;
super.setLength(newLength);
}
//缩小数组（capacity）容量至字符串长度本身的长度
@Override
public synchronized void trimToSize() {
super.trimToSize();
}
//返回指定index的字符
@Override
public synchronized char charAt(int index) {
if ((index < 0) || (index >= count))
throw new StringIndexOutOfBoundsException(index);
return value[index];
}
//返回指定index的ASCII码值
@Override
public synchronized int codePointAt(int index) {
return super.codePointAt(index);
}
//返回指定index - 1的ASCII码值
@Override
public synchronized int codePointBefore(int index) {
return super.codePointBefore(index);
}
//返回指定范围的ASCII码数量
@Override
public synchronized int codePointCount(int beginIndex, int endIndex) {
return super.codePointCount(beginIndex, endIndex);
}
//返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。
@Override
public synchronized int offsetByCodePoints(int index, int codePointOffset) {
return super.offsetByCodePoints(index, codePointOffset);
}
//从StringBuffer中截断指定位置的序列到dst字符数组的dstBegin开始处。
@Override
public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,int dstBegin)
{
super.getChars(srcBegin, srcEnd, dst, dstBegin);
}
//更改指定index的字符
@Override
public synchronized void setCharAt(int index, char ch) {
if ((index < 0) || (index >= count))
throw new StringIndexOutOfBoundsException(index);
toStringCache = null;
value[index] = ch;
}
//多种类型的append
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}
//ASCII码的append
@Override
public synchronized StringBuffer appendCodePoint(int codePoint) {
toStringCache = null;
super.appendCodePoint(codePoint);
return this;
}
//删除指定范围的字符串
@Override
public synchronized StringBuffer delete(int start, int end) {
toStringCache = null;
super.delete(start, end);
return this;
}
//删除指定index字符
@Override
public synchronized StringBuffer deleteCharAt(int index) {
toStringCache = null;
super.deleteCharAt(index);
return this;
}
//替换指定范围的字符串
@Override
public synchronized StringBuffer replace(int start, int end,String str) {
toStringCache = null;
super.replace(start, end, str);
return this;
}
//指定开始处后的子串
@Override
public synchronized String substring(int start) {
return substring(start, count);
}
//指定范围的子串
@Override
public synchronized CharSequence subSequence(int start, int end) {
return super.substring(start, end);
}
//指定字符数组的offset（偏移量）处开始，长len的字符串插入到StringBuffer的index处
//剩余insert略
@Override
public synchronized StringBuffer insert(int index, char[] str, int offset,int len)
{
toStringCache = null;
super.insert(index, str, offset, len);
return this;
}
//返回指定字符串的的开始处，无则返回-1
@Override
public int indexOf(String str) {
// Note, synchronization achieved via invocations of other StringBuffer methods
return super.indexOf(str);
}
//返回指定字符串的最后
@Override
public int lastIndexOf(String str) {
// Note, synchronization achieved via invocations of other StringBuffer methods
return lastIndexOf(str, count);
}
//反转StringBuffer
@Override
public synchronized StringBuffer reverse() {
toStringCache = null;
super.reverse();
return this;
}
//转化为字符串String
@Override
public synchronized String toString() {
if (toStringCache == null) {
toStringCache = Arrays.copyOfRange(value, 0, count);
}
return new String(toStringCache, true);
}
//序列化与反序列化
private static final java.io.ObjectStreamField[] serialPersistentFields =
{
new java.io.ObjectStreamField("value", char[].class),
new java.io.ObjectStreamField("count", Integer.TYPE),
new java.io.ObjectStreamField("shared", Boolean.TYPE),
};
private synchronized void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
java.io.ObjectOutputStream.PutField fields = s.putFields();
fields.put("value", value);
fields.put("count", count);
fields.put("shared", false);
s.writeFields();
}
/**
* readObject is called to restore the state of the StringBuffer from
* a stream.
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
java.io.ObjectInputStream.GetField fields = s.readFields();
value = (char[])fields.get("value", null);
count = fields.get("count", 0);
}
StringBuilder与StringBuffer相比，除了方法没有Synchronized外其与相同。
