public final class StringBuffer extends AbstractStringBuilder implements java.io.Serializable, CharSequence {//一个缓存用来存储最后一次调用toString返回的值,每当StringBuffer被修改就把该缓存清空private transient char[] toStringCache;public StringBuffer() {super(16);}public StringBuffer(int capacity) {super(capacity);}//...more constructs,提供与父类一致的构造器,StringBuffer的构造器总是调用父类的构造器
@Overridepublic synchronized int length() {//返回容器中字符的数量return count;}@Overridepublic synchronized int capacity() {//返回容器的大小return value.length;}@Overridepublic synchronized void ensureCapacity(int minimumCapacity) {//保证容器足够大if (minimumCapacity > value.length) {expandCapacity(minimumCapacity);}}@Overridepublic synchronized void trimToSize() {//将容器的大小与容器的字符数量变成一致的super.trimToSize();}//setLength是修改了StringBuffer,所以要把toStringCache设置为nullpublic synchronized void setLength(int newLength) {toStringCache = null;super.setLength(newLength);}//...append,insert方法还有其他需要同步化的方法都是覆盖父类,用synchronized使方法同步化,同时那些修改了StringBuffer的方法,需要先把toStringCache设置为null//下面几个insert方法没有用synchronized来实现同步化,上面的解释说这些方法的同步化是通过调用其他StringBuffer方法来实现的public StringBuffer insert(int dstOffset, CharSequence s) {// Note, synchronization achieved via invocations of other StringBuffer methods// after narrowing of s to specific type// Ditto for toStringCache clearingsuper.insert(dstOffset, s);return this;}public  StringBuffer insert(int offset, boolean b) {// Note, synchronization achieved via invocation of StringBuffer insert(int, String)// after conversion of b to String by super class method// Ditto for toStringCache clearingsuper.insert(offset, b);return this;}public StringBuffer insert(int offset, int i) {// Note, synchronization achieved via invocation of StringBuffer insert(int, String)// after conversion of i to String by super class method// Ditto for toStringCache clearingsuper.insert(offset, i);return this;}public StringBuffer insert(int offset, long l) {// Note, synchronization achieved via invocation of StringBuffer insert(int, String)// after conversion of l to String by super class method// Ditto for toStringCache clearingsuper.insert(offset, l);return this;}public StringBuffer insert(int offset, float f) {// Note, synchronization achieved via invocation of StringBuffer insert(int, String)// after conversion of f to String by super class method// Ditto for toStringCache clearingsuper.insert(offset, f);return this;}public StringBuffer insert(int offset, double d) {// Note, synchronization achieved via invocation of StringBuffer insert(int, String)// after conversion of d to String by super class method// Ditto for toStringCache clearingsuper.insert(offset, d);return this;}public int indexOf(String str) {// Note, synchronization achieved via invocations of other StringBuffer methodsreturn super.indexOf(str);}public int lastIndexOf(String str) {// Note, synchronization achieved via invocations of other StringBuffer methodsreturn lastIndexOf(str, count);}//这个toString方法很重要,如果toStringCache为null时,会把当前的value复制一份新的给它,否则返回String(toStringCache)public synchronized String toString() {if (toStringCache == null) {toStringCache = Arrays.copyOfRange(value, 0, count);}return new String(toStringCache, true);}//下面的三个方法是为了实现StringBuffer的序列化和反序列化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();}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);}