java源码分析（4）-AbstractStringBuilder



AbstractStringBuilder

1.AbstractStringBuilder

为抽象类，主要的属性有两个，一个为value，一个为count，value用于存放值，count用于管理该类的容量

char value[];int count;public int length() {//length方法返回的是count的值，而不是value.lengthreturn count;}public int capacity() {//capacity方法返回的是value.length,用以返回容量return value.length;}public void ensureCapacity(int minimumCapacity) {if (minimumCapacity > value.length) {    expandCapacity(minimumCapacity);}}void expandCapacity(int minimumCapacity) {int newCapacity = (value.length + 1) * 2;//自动扩容机制，每次扩容(value.length+1)*2        if (newCapacity < 0) {            newCapacity = Integer.MAX_VALUE;//若传入的参数小于0，则直接把容量设置到Integer的最大值        } else if (minimumCapacity > newCapacity) {    newCapacity = minimumCapacity;//若扩容后的容量还是小于传入的参数，则将传入的参数设为容量}        value = Arrays.copyOf(value, newCapacity);}public void trimToSize() {        if (count < value.length) {            value = Arrays.copyOf(value, count);//当count小于value.length时，将value多余长度的值删除，时value.length的长度等于count        }}

2.trimToSize()

  用于保留value的值，保留的长度为count的值，只有当count的值小于value.length时才起作用，

<strong> public void trimToSize() {        if (count < value.length) {            value = Arrays.copyOf(value, count);        }    }</strong>

3.setLength(int newLength)

public void setLength(int newLength) {if (newLength < 0)    throw new StringIndexOutOfBoundsException(newLength);if (newLength > value.length)    expandCapacity(newLength);//当传入的值大于value.length时，需要扩容if (count < newLength) {    for (; count < newLength; count++)value[count] = '\0';//为新扩容的元素赋值'\0'，为结束符} else {            count = newLength;//若count小于输入参数，则将count的值设置为输入的值        }}

4.getChars(int srcBegin, int srcEnd, char dst[],int dstBegin)

append依赖的一个方法，用以添加一个字符串数组

public void getChars(int srcBegin, int srcEnd, char dst[],                                      int dstBegin)    {if (srcBegin < 0)    throw new StringIndexOutOfBoundsException(srcBegin);if ((srcEnd < 0) || (srcEnd > count))    throw new StringIndexOutOfBoundsException(srcEnd);        if (srcBegin > srcEnd)            throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);//用于添加字符串，将value的值添加到dst[]中}

5.append()

在对象后拼接字符串或其他对象，效率较高，可以观察到，在拼接时并没有创建新的对象，也没有舍弃旧的对象，相对于String的机制，性能提升相当明显。

public AbstractStringBuilder append(String str) {if (str == null) str = "null";//若传入的字符串长度为0，则默认添加null        int len = str.length();if (len == 0) return this;//若添加的字符串长度为0，则直接返回对象本身（不进行添加）int newCount = count + len;if (newCount > value.length)    expandCapacity(newCount);//检验容量，若容量不够则扩容str.getChars(0, len, value, count);//将str的值添加到value后count = newCount;//容量count更新return this;}public AbstractStringBuilder append(StringBuffer sb) {if (sb == null)            return append("null");//传入的StringBuffer长度为零，默认添加nullint len = sb.length();int newCount = count + len;if (newCount > value.length)    expandCapacity(newCount);//检验容量，有需要则执行扩容sb.getChars(0, len, value, count);count = newCount;//更新容量count的值return this;}public AbstractStringBuilder append(CharSequence s) {        if (s == null)            s = "null";        //根据序列类型的不同，执行不同的添加方法        if (s instanceof String)            return this.append((String)s);        if (s instanceof StringBuffer)            return this.append((StringBuffer)s);        return this.append(s, 0, s.length());}public AbstractStringBuilder append(int i) {        if (i == Integer.MIN_VALUE) {            append("-2147483648");//Integer最小值为特例，特殊处理            return this;        }        int appendedLength = (i < 0) ? stringSizeOfInt(-i) + 1                                      : stringSizeOfInt(i);//判断Integer的位数，负数有负号，要多加一位        int spaceNeeded = count + appendedLength;        if (spaceNeeded > value.length)            expandCapacity(spaceNeeded);Integer.getChars(i, spaceNeeded, value);        count = spaceNeeded;        return this;}final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,                                     99999999, 999999999, Integer.MAX_VALUE };static int stringSizeOfInt(int x) {        for (int i=0; ; i++)            if (x <= sizeTable[i])                return i+1;}

6.delete(int start, int end)

用以删除一部分的字符

public AbstractStringBuilder delete(int start, int end) {        //验证参数的有效性if (start < 0)    throw new StringIndexOutOfBoundsException(start);if (end > count)    end = count;//结束下标大于count时，将count设为结束下标if (start > end)    throw new StringIndexOutOfBoundsException();        int len = end - start;        if (len > 0) {            System.arraycopy(value, start+len, value, start, count-end);//执行删除            count -= len;//重置count大小        }        return this;}

7.replace(int start, int end, String str)

替换本身对象中的一部分字符

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);//计算替换后字符串的长度以此判断是否需要进行扩容if (newCount > value.length)    expandCapacity(newCount);        //替换的步骤为，先删除要替换的部分，再拼接要添加的部分        System.arraycopy(value, end, value, start + len, count - end);        str.getChars(value, start);        count = newCount;//更新count值        return this;}

8.insert(int index, char str[], int offse,int len)

在对象中间插入字符串数组

public AbstractStringBuilder insert(int index, char str[], int offset,                                        int len)    {        //验证参数有效性        if ((index < 0) || (index > length()))    throw new StringIndexOutOfBoundsException(index);        if ((offset < 0) || (len < 0) || (offset > str.length - len))            throw new StringIndexOutOfBoundsException(                "offset " + offset + ", len " + len + ", str.length "                 + str.length);int newCount = count + len;if (newCount > value.length)//验证是否要扩容    expandCapacity(newCount);System.arraycopy(value, index, value, index + len, count - index);//先在value中建立起用于存放插入值的空位System.arraycopy(str, offset, value, index, len);//向空位中插入strcount = newCount;//更新count值return this;    }

9. reverse()

将对象本身的字符顺序调转后返回给原对象

public AbstractStringBuilder reverse() {//反转字符串boolean hasSurrogate = false;int n = count - 1;        //采用从中间向两端遍历，对换对称位置上的字符for (int j = (n-1) >> 1; j >= 0; --j) {    char temp = value[j];    char temp2 = value[n - j];    if (!hasSurrogate) {//验证每个字符的编码是否在范围内hasSurrogate = (temp >= Character.MIN_SURROGATE && temp <= Character.MAX_SURROGATE)    || (temp2 >= Character.MIN_SURROGATE && temp2 <= Character.MAX_SURROGATE);    }    value[j] = temp2;    value[n - j] = temp;}if (hasSurrogate) {   //例如憨子由两个字符组成，直接反转后，用以表示一个汉字的两个字符顺序错了，需要重新调整    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;    }}    }}return this;}

可以看到，这里需要考虑到字符编码的问题，例如汉字由两个字符组成，将对称位置的字符互换后，两个用以表示一个汉字的字符顺序会颠倒，需要互换这两个字符的位置