共同学习Java源代码--常用工具类--AbstractStringBuilder（九）

    public int indexOf(String str) {
        return indexOf(str, 0);

    }

    public int indexOf(String str, int fromIndex) {
        return String.indexOf(value, 0, count, str, fromIndex);
    }

这两个方法一起看，第一个方法调用第二个方法第二个方法调用String类的静态方法。

    public int lastIndexOf(String str) {
        return lastIndexOf(str, count);
    }

    public int lastIndexOf(String str, int fromIndex) {
        return String.lastIndexOf(value, 0, count, str, fromIndex);
    }

这两个方法也是同样道理，不多说了。

    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;
    }

    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;
                }
            }
        }
    }

这两个方法一起看,第一个方法先创建一个boolean变量表示是否有代理字符，默认为false，然后创建一个变量n，赋值为长度count减一。

进入for循环，循环变量为j，j的初始值为n-1右移一位，也就是count-2右移一位，也就是count-2/2，然后j递减。

进入for循环后，创建变量k，其值为n-j，也就是count-1-j，然后分别判断value中j下标和k下标处的元素是否是代理区元素，其实就是从value数组的中间向左右两边扩散，然后将这些元素互换，最中间的元素不管。如果有代理区元素，那么就调用第二个方法。如果没有，就返回本对象，当然本对象已经被处理过了，也就是颠倒过来了。

第二个方法就是先进入for循环遍历每个元素，判断如果是低代理元素，那么将c1变量赋值为下一个元素，再判断c1是否为高代理元素，如果是，那么c1和之前的元素互换。

    public abstract String toString();

这个方法有待实现类实现。

    final char[] getValue() {
        return value;
    }

这个方法返回value。

至此AbstractStringBuilder类介绍完毕。