StringBuffer源码解析

StringBuffer源码解析
首先看下StringBuffer类属于哪个下面的包名以及类修饰部分
StringBuffer是属于java.lang类库下面的实体类以及他所属的报名，具体是在这样一个包体下面的一个类

package java.lang;  //这是一个包体的命名的规则

 //其二点就是这个类是被fianl修饰以及继承了AbstactStringBuilder这个接口，接下来可以看下这个接口中主要中都有方法与属性
public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence   


//StringBuffer中的无参构造函数
public StringBuffer() {
        super(16);   //注意到这里默认的容量是16
    }

//这里你也可以指定StringBuffer的容量字节数
 public StringBuffer(int capacity) {
        super(capacity);
    }


//首先确定一个StringBuffer的容量是多少，然后将字符拼接
 public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }

第二点：StringBuffer中都有哪些方法是线程安全的

@Override
    public synchronized int length() {
        return count;
    }

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


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

    /**
     * @since      1.5
     */
    @Override
    public synchronized void trimToSize() {
        super.trimToSize();
    }

@Override
    public synchronized void setLength(int newLength) {
        toStringCache = null;
        super.setLength(newLength);
    }

    /**
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * @see        #length()
     */
    @Override
    public synchronized char charAt(int index) {
        if ((index < 0) || (index >= count))
            throw new StringIndexOutOfBoundsException(index);
        return value[index];
    }

    /**
     * @since      1.5
     */
    @Override
    public synchronized int codePointAt(int index) {
        return super.codePointAt(index);
    }

    /**
     * @since     1.5
     */
    @Override
    public synchronized int codePointBefore(int index) {
        return super.codePointBefore(index);
    }

    /**
     * @since     1.5
     */
    @Override
    public synchronized int codePointCount(int beginIndex, int endIndex) {
        return super.codePointCount(beginIndex, endIndex);
    }

    /**
     * @since     1.5
     */
    @Override
    public synchronized int offsetByCodePoints(int index, int codePointOffset) {
        return super.offsetByCodePoints(index, codePointOffset);
    }

 这些都是从其父类中继承过来的方法以及接口:从上面我们能够看见线程安全的方法主要都有以下这些

Length()；setLength();charAt(); trimToSize(); capacity(),这些线程安全的方法
第三点：append(Object obj)这个方法的解析

@Override
    public synchronized StringBuffer append(Object obj) {
        toStringCache = null;
        super.append(String.valueOf(obj));
        return this;
    }

在上面的代码中我们可以看见到的首先是将Object类型利用String.valueOf()方法将Object类转换为String,在这其中我们也看见了ValueOf（）方法其实也是利用到toString（）方法
代码如下所示：

public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
    }

接着第二步的阶段所看：也就是调用了Append方法这个方法是父类中的一个方法，可以看一下这个方法的内部代码是怎样的逻辑

public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        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
        if (minimumCapacity - value.length > 0) {
            //这里的value 其实就是一个char类型的数组，这里Arrays.copyOf来做相当于赋值的操作
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }     

再下面就是Arrays中的copy方法：

*/
public static char[] copyOf(char[] original, int newLength) {
    char[] copy = new char[newLength];
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

由此可以看到我们中的代码执行顺序其实就是从System,arraycopy < Arrays.copyof方法