Java源码阅读之AbstractStringBuilder

类定义

abstract class AbstractStringBuilder implements Appendable, CharSequence{}

1.类被声明为包访问权限且是抽象类，我们不能继承实现该类，且该类是StringBuilder和StringBuffer的父类
2.实现了Appendable接口，可以调用append等方法向末尾添加字符串，且也说明了AbstractStringBuilder的子类对象是可变类型的对象
3.该类实现了CharSequence接口

类属性

// 存储字符的数组
char[] value;

// 当前存储的字符数，小于等于value.length
int count;

// 最大数组大小
private static final int MAX_ARRAY_SIZE = Integet.MAX_VALUE - 8;

构造函数

AbstractStringBuilder(){}

// 用指定的容量大小来创建builder
AbstractStringBuilder(int capacity){
	value = new char[capacity];
}

方法

// 该方法是CharSequence中的方法，用于返回当前序列的长度，也就是实际存储的字符的数量
public int length(){
	return count;
}

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

// 确保当前的容量能够满足minimumCapacity
// 如果不能满足，将会分配一个新的数组来满足minimumCapacity
// 新数组的大小：minimumCapacity或者是原有大小的2倍+2
public void ensureCapacity(int minimumCapacity){
	// 如果传递的参数是负数，直接返回
	if(minimumCapacity > 0){
		ensureCapacityInternal(minimumCapacity);
	}
}

void ensureCapacityInternal(int minimumCapacity){
	// 如果当前的容量不能满足minimumCapactity则返回一个minimumCapacity的新数组
	if(minimumCapacity - value.length > 0){
		value = Arrays.copyOf(value, newCapacity(minimumCapacity));
	}
}

// 返回新的数组大小，新数组大小满足两个要素
// 1.至少大于minimumCapacity
// 2.至少大于原有大小 oldCapactiy*2 + 2
private int newCapacity(int minCapacity){
	int newCapacity = (value.length << 1) + 2;
	if(newCapacity - minCapacity< 0){
		newCapacity = minCapacity;
	}
	return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0) ?
		hugeCapacity(newCapacity) : newCapacity;
}

// 如果指定的容量超过了指定的最大值
private int hugeCapacity(int minCapacity){
	if(Integer.MAX_VALUE - minCapacity < 0){
		throw new OutOfMemoryError();
	}
	return (minCapacity > MAX_ARRAY_SIZE) ? minCapacity : MAX_ARRAY_SIZE;
}

public void trimToSize(){
	if(value.length - count > 0){
		value = Arrays.copyOf(value, count);
	}
}

// 为序列设置新的长度,多出的内容用空字符填充
// 如果指定newLength大于原来的容量，则进行扩容，如果不大于则直接进行截断
public void setLength(int newLength){
	if(newLenght < 0)
		throw new StringIndexOutOfBoundsException(newLength);
	ensureCapacityInternal(newLength);

	if(count < newLength){
		Array.fill(value, count, newLength, '\0');
	}
	count = newLength;
}

public char charAt(int index){
	if(index < 0 || index >= count){
		throw new StringIndexOutOfBoundsException(index);
	}
	return value[index];
}

public AbstractStringBuilder append(String str){
	if(str == null){
		// 添加"null"字符串
		return appendNull();
	}
	int len = str.length;
	ensureCapacityInternal(count + len);
	str.getChars(0, len, value, count);
	count += len;
	return this;
}

public AbstractStringBuild append(CharSequence s){
	if(s == null){
		return appendNull();
	}
	if(s instanceof String){
		return this.append((String)s);
	}
	if(s instanceof AbstractStringBuilder){
		return this.append((AbstractStringBuilder) s);
	}
	return this.append(s, 0, s.length());
}

public AbstractStringBuilder append(boolean b) {
    if (b) {
        ensureCapacityInternal(count + 4);
        value[count++] = 't';
        value[count++] = 'r';
        value[count++] = 'u';
        value[count++] = 'e';
    } else {
        ensureCapacityInternal(count + 5);
        value[count++] = 'f';
        value[count++] = 'a';
        value[count++] = 'l';
        value[count++] = 's';
        value[count++] = 'e';
    }
    return this;
}


public AbstractStringBuilder revers(){
	boolean hasSurrogate = false;
	int n = count -1;
	// 这里设置成(n-1)/2可以避免这奇数的情况下交换中心元素自身
	for(int j = ((n-1) >> 1); j >=0; j--){
		int k = n-j;
		char ck = value[k];
		char cj = value[j];
		value[k] = cj;
		value[j] = ck;
		if(Character.isSurrogate(ck) || Character.isSurrogate(cj)){
			hasSurrogate = true;
		}
	}
	if(hasSurrogate){
		reverseAllValidSurrogatePairs();
	}
	return this;

}

// 将辅平面的编码逆转回来
private void reverserAllValidSurrogatePairs(){
	for(int i = 0; i < count - 1; i++){
		char c1 = value[i];
		if(Character.isLowSurrogate(c1)){
			char c2 = value[i+1];
			if(Character.isHighSurrogate(c2)){
				value[i++] = c2;
				value[i] = c1;
			}
		}
	}
}