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);
}