java源码分析(6)-StringBuffer



StringBuffer

1.StringBuffer类

StringBuffer类由final修饰，故不能被继承，同时StringBuffer继承了AbstractStringBuilder，大量调用了AbstractStringBuilder中的方法，同时实现了java.io.Serializable接口，自定义了序列化方法，实现了CharSequence接口

public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
public StringBuffer() {
	super(16);//默认容量为16
    }
public StringBuffer(int capacity) {
	super(capacity);
    }
public StringBuffer(String str) {
	super(str.length() + 16);//new StringBuffer时传入字符串，默认容量将变为字符串长度加16
	append(str);
    }
public StringBuffer(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }

2.同步方法

StringBuffer中的方法基本与父类相同，但是都用synchronize修饰，以保证线程的安全性，同时也使得StringBuffer的性能大大降低。

所有可以修改属性的方法都实现了同步，防止出现两个线程同时修改StringBuffer的而出现线程安全问题

public synchronized int length() {
	return count;
    }
public synchronized int capacity() {
	return value.length;
    }
public synchronized void ensureCapacity(int minimumCapacity) {
	if (minimumCapacity > value.length) {
	    expandCapacity(minimumCapacity);
	}
    }
public synchronized void trimToSize() {
        super.trimToSize();
    }
public synchronized StringBuffer append(Object obj) {
	super.append(String.valueOf(obj));
        return this;
    }

public synchronized StringBuffer append(String str) {
	super.append(str);
        return this;
    }
public synchronized StringBuffer append(StringBuffer sb) {
        super.append(sb);
        return this;
    }
public StringBuffer append(CharSequence s) {
        if (s == null)
            s = "null";
        if (s instanceof String)
            return this.append((String)s);
        if (s instanceof StringBuffer)
            return this.append((StringBuffer)s);
        return this.append(s, 0, s.length());
    }
public synchronized StringBuffer append(CharSequence s, int start, int end) 
    {
        super.append(s, start, end);
        return this;
    }
public synchronized StringBuffer append(char str[]) { 
        super.append(str);
        return this;
    }
public synchronized StringBuffer append(char str[], int offset, int len) {
        super.append(str, offset, len);
        return this;
    }
public synchronized StringBuffer append(boolean b) {
        super.append(b);
        return this;
    }
public synchronized StringBuffer append(char c) {
        super.append(c);
        return this;
    }
public synchronized StringBuffer append(int i) {
	super.append(i);
        return this;
    }
public synchronized StringBuffer appendCodePoint(int codePoint) {
	super.appendCodePoint(codePoint);
	return this;
    }
public synchronized StringBuffer append(long lng) {
        super.append(lng);
	return this;
    }
public synchronized StringBuffer append(float f) {
	super.append(f);
	return this;
    }
public synchronized StringBuffer append(double d) {
	super.append(d);
	return this;
    }

3.序列化(反序列化)方法的实现

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);//序列化value，count，false将他们放入对应的

序列化属性域中
        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 = (int)fields.get("count", 0);
    }