Java源码阅读之StringBuffer

• 类定义
• 类属性
• 构造函数
• 方法

类定义

类属性

// 用于记录当前已经构建的String的缓存，不能被序列化
// 即是调用toString时的字符集
// 缓存的是每一次调用toString时的字符
// 每当buffer对象发生改变，toStringCache都会被清空
private transient char[] toStringCache;
           

构造函数

// 默认构造函数，将容量默认初始化为16
public StringBuffer(){
	super(16);
}

public StringBuffer(int capacity){
	// 用指定的容量大小初始化StringBuffer
	super(capacity);
}

public StringBuffer(String str){
	// 用字符串初始化StringBuffer时，容量为16加上str的长度
	super(str.length + 16);
	append(str);
}

public StringBuffer(CharSequence seq){
	this(seq.length() + 16);
	append(seq);
}
           

方法

public synchronized int length(){
	return count;
}

public synchronized int capacity(){
	return value.length;
}

public synchronized void ensureCapacity(int minimumCapacity){
	super.ensureCapacity(minimumCapacity);
}

public synchronized void trimToSize(){
	super.trimToSize();	
}

pubic synchronized void setLength(int newLength){
	toStringCache = null;
	super.setLength(newLength);
}

public synchronized char charAt(int index){
	if(index < 0 || index >= count){
		throw new StringIndexOutOfBoundsException(index);
	}
	return value[index];
}

// 从当前StringBuffer中复制srcBegin到srcEnd的字符到dst从dstOffset开始中
public synchronized void getChars(int srcBegin, int srcEnd, char[] dst, int dstOffset){
	super.getChars(srcBegin, srcEnd, dst, dstOffset);
}

public synchronized void setCharAt(int index, char ch){
	if(index < 0 || index >= count){
		throw new StringIndexOutOfBoundsException(index);
	}
	//buffer类发生改变，将toStringCache清空
	toStringCache = null;
	value[index] = ch;
}

public synchronized StringBuffer append(Objec obj){
	toStringCache = null;
	super.append(String.valueOf(obj));
	// String.valueOf(obj)不会报错，如果obj==null，则追加"null"字符串
	return this;
}

public synchronized StringBuffer append(String str){
	toStringCache = null;
	super.append(str);
	return this;
}

public synchronized StringBuffer append(StringBuffer sb){
	toStringCache = null;
	super.append(sb);
	return this;
}

// 该方法虽然没有加synchronized关键字，但是该方法仍然是同步的
// 方法调用顺序 AbstractStringBuilder.insert(dstOffset, b)->StringBuffer.insert(offset, String)这个方法是一个同步方法，故该方法也是同步的,其他的方法类似
public StringBuffer insert(int dstOffset, boolean b){
	super.insert(dstOffset, b);
	return this;
}

public synchronized StringBuffer reverse(){
	toStringCache = null;
	super.reverse();
	return this;
}

public synchronized String toString(){
	if(toStringCache == null){
		toStringCache = Arrays.copyOfRange(value, 0, count);
	}
	return new String(toStringCache, true);
}

// 用于指定StringBuffer类在序列化时，需要被序列化的属性
private final static java.io.ObjectStreamField[] serialPersistenFileds = {
	new java.io.ObjectStreamFiled("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);
}