StringBuffer 源码

1:定义

public final class StringBuffer extends AbstractStringBuilder implements java.io.Serializable, CharSequence

2:属性

 static final long serialVersionUID = 3388685877147921107L;

3:构造函数

(1)构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。

 public StringBuffer() {
        super(16);
    }

继承父类的AbstractStringBuilder的构造函数

AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

(2)构造一个不带字符，但具有指定初始容量的字符串缓冲区

public StringBuffer(int capacity) {
        super(capacity);
    }

(3)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度

public StringBuffer(String str) {
//这个执行父类的带参构造函数AbstractStringBuilder(int capacity) 
        super(str.length() + 16);
        append(str);
    }

append 是用 synchronized 修饰的,所以是线程安全的

public synchronized StringBuffer append(String str) {  
        //执行父类的append(str)  
        super.append(str);  
        return this;  
} 

父类 AbstractStringBuilder 的 append 方法

 public AbstractStringBuilder append(String str) {
        if (str == null) str = "null";
        int len = str.length();
        ensureCapacityInternal(count + len);//扩大容量      
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }

//扩大容量

private void ensureCapacityInternal(int minimumCapacity) {  
        // overflow-conscious code:判断是否需要扩容，也就是说原来的capacity是否足够大  
        if (minimumCapacity - value.length > 0) //20-19=1,1>0  
            expandCapacity(minimumCapacity);  
    }  

void expandCapacity(int minimumCapacity) {
        //新容量  原始容量 * 2 + 2
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)     //扩容后的容量-字符串实际长度<0(就是说如果扩容后还装不下)，
            newCapacity = minimumCapacity;