Java源码阅读 - AbstarctStringBuilder

1. 基础类定义及属性

	 // 实现appendable需实现方法append，StringBuilder与StringBuffer常用方法
	abstract class AbstractStringBuilder implements Appendable, CharSequence

    // 字符数组
    char[] value;
 
    // 实际存的字符个数
    int count;
 
    // 无参构造方法
    AbstractStringBuilder() {
    }
 
    // 初始化数组大小的构造方法
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }
    // 返回count
    public int length() {
        return count;
    }
    // 当前数组的长度
    public int capacity() {
        return value.length;
    }

2. 扩容方法

   // 扩容逻辑，当前容量先*2+2看是否足够，如果不够直接使用需要的容量扩容，需要的容量不可以大于最大容量MAX_ARRAY_SIZE
   private int newCapacity(int minCapacity) {
       // overflow-conscious code
       int newCapacity = (value.length << 1) + 2;
       if (newCapacity - minCapacity < 0) {
           newCapacity = minCapacity;
       }
       return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
           ? hugeCapacity(minCapacity)
           : newCapacity;
   }
	// 判断是否大于最大数组容量
   private int hugeCapacity(int minCapacity) {
       if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
           throw new OutOfMemoryError();
       }
       return (minCapacity > MAX_ARRAY_SIZE)
           ? minCapacity : MAX_ARRAY_SIZE;
   }

   private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
   @Native public static final int MAX_VALUE = 0x7fffffff;

// 去除未使用容量
public void trimToSize() {
       if (count < value.length) {
           value = Arrays.copyOf(value, count);
       }
   }

// 判断长度是否足够，不够先扩容
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;
   }

3. append布尔型及null

// 拼接true，false
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;
    }
// 拼接null    
private AbstractStringBuilder appendNull() {
        int c = count;
        ensureCapacityInternal(c + 4);
        final char[] value = this.value;
        value[c++] = 'n';
        value[c++] = 'u';
        value[c++] = 'l';
        value[c++] = 'l';
        count = c;
        return this;
    }

// 删除字符串方法
public AbstractStringBuilder deleteCharAt(int index) {
        if ((index < 0) || (index >= count))
            throw new StringIndexOutOfBoundsException(index);
        System.arraycopy(value, index+1, value, index, count-index-1);
        count--;
        return this;
    }

替换字符串，主要使用系统方法system.arraycopy

// 替换字符串方法
public AbstractStringBuilder replace(int start, int end, String str) {
       if (start < 0)
           throw new StringIndexOutOfBoundsException(start);
       if (start > count)
           throw new StringIndexOutOfBoundsException("start > length()");
       if (start > end)
           throw new StringIndexOutOfBoundsException("start > end");

       if (end > count)
           end = count;
       int len = str.length();
       int newCount = count + len - (end - start);
       ensureCapacityInternal(newCount);

       System.arraycopy(value, end, value, start + len, count - end);
       str.getChars(value, start);
       count = newCount;
       return this;
   }
   
// system.arraycopy 方法,指定源对象和目的对象，分别设定复制开始点，分别复制在拼接
public static native void arraycopy(Object src,  int  srcPos,
                                   Object dest, int destPos,
                                   int length);

4. 反转字符串

public AbstractStringBuilder reverse() {
        boolean hasSurrogates = false;
        int n = count - 1;
        for (int j = (n-1) >> 1; j >= 0; j--) {  // 计算(n-1)/2 定位中位数
            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;
    }
 
    /** 增补字符由于有2位字符，需要进行单独反转 */
    private void reverseAllValidSurrogatePairs() {
        for (int i = 0; i < count - 1; i++) {
            char c2 = value[i];
            if (Character.isLowSurrogate(c2)) {
                char c1 = value[i + 1];
                if (Character.isHighSurrogate(c1)) {
                    value[i++] = c1;
                    value[i] = c2;
                }
            }
        }
    }