JDK1.8 (一) AbstractStringBuilder 及其子类源码分析

JDK1.8 (一) AbstractStringBuilder 及其子类源码分析

首先贴出类继承体系图,这次博客将 StringBuffer,StringBuilder 一起介绍掉

总结:子类和父类方法基本一致,StringBuffer 加了 synchronized 安全性能较低,其它一致,String 比这两者慢的原因是,当添加太多字符串时候,这两者只需要扩容,不需要新建对象,创建对象内存管理成本高所以慢,而 String 每次都需要创建新对象,所以慢

	int otherLen = str.length();
       if (otherLen == 0) {
           return this;
       }
       int len = value.length;
       //这里copy 底层也是调用System.arraycopy() 方法
       char buf[] = Arrays.copyOf(value, len + otherLen);
       str.getChars(buf, len);
       return new String(buf, true);//这里每次创建新对象慢在这里

• 成员属性

	//注意:容量 capacity 的大小是这里char 数组的长度 length
	char[] value;//存值存在这个 char 数组中 
	public int capacity() {
        return value.length;
    }
	
    int count;//添加数量大小
    public int length() {
        return count;
    }

• 构造方法

	//还有个缺省的没粘贴,这里可以看到,新建 char 数组给个自定义大小
	//这个方法子类初始化时候都调用这个,指定 16 空间大小
	AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

	//StringBuffer 默认缺省指定 16 空间大小
	public StringBuffer() {
        super(16);
    }

• 扩容机制

	 //之前的 char.length * 2 +2,加了一下安全校验
	void expandCapacity(int minimumCapacity) {
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        value = Arrays.copyOf(value, newCapacity);
    }

• append 方法

	//删掉一些安全判断的,直接上干货
	//①:先扩容,其次再通过System.arraycopy 来拷贝数据,
	//这里1.8之前可以看见源码,现在是 native 其它语言写的更快 
 	public AbstractStringBuilder append(String str) {
        int len = str.length();
        ensureCapacityInternal(count + len);//这里就是调用扩容方法扩容
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }
    
	public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }

• crud 就不介绍了,核心都是 System.arraycopy(…) 方法 或者是 Arrays.copy(),这种我单独抽一个章节来写

• reverse

	//容量大小 -1 右移一位,循环一半容量大小-1 交换收尾两元素的值,从而实现倒置
	 public AbstractStringBuilder reverse() {
        boolean hasSurrogates = false;
        int n = count - 1;
        for (int j = (n-1) >> 1; j >= 0; j--) {
            int k = n - j;
            char cj = value[j];
            char ck = value[k];
            value[j] = ck;
            value[k] = cj;
            if (Character.isSurrogate(cj) ||
                Character.isSurrogate(ck)) {
                hasSurrogates = true;
            }
        }
        if (hasSurrogates) {
            reverseAllValidSurrogatePairs();
        }
        return this;
    }