jdk源码阅读笔记-AbstractStringBuilder

　　AbstractStringBuilder 在java.lang 包中，是一个抽象类，实现 Appendable 接口和 CharSequence 接口，这个类的诞生是为了解决 String 类在创建对象的时候总是创建新的对象的问题的。AbstractStringBuilder 有两个子类，分别是 StringBuilder 和 StringBuffer，这两个类的区别将会在下面说到。

　　从源码中可以看出来，AbstractStringBuilder类和String类是非常相似的，设计的思想可以说是一模一样，其内部维护的都是一个char类的数组。唯一的区别在于这个数组的修饰符不一样，String类维护的是一个不可变的数组，而后者维护的则是一个可变的数组。

　　AbstractStringBuilder源码：

String类源码：

　　AbstractStringBuilder 的应用场景

　　该类主要适用于在短时间内创建大量字符串的场景，比如在一个循环体中需要拼接一个非常长的字符串时，可以考虑 AbstractStringBuilder 的实现类来创建字符串，这样不管这个字符串有多长最终都只会生成一个对象，但是如果在循环体中使用String来创建字符串时，此时会创建出大量的对象，这样不仅影响性能，同时如果内存较小的情况下很容易发生oom异常。下面列举一下使用的建议：

public class Test {

    public static void main(String[] args) {
        /**
         * 不建议这样做:
         * 耗时：30726
         */
        String str = "";
        long start = System.currentTimeMillis();
        for (int i = ; i < ; i++) {
            str += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("耗费时间：" + (end - start));
        /**
         * 推荐做法：
         * 耗时：2
         */
        start = System.currentTimeMillis();
        StringBuilder builder = new StringBuilder();
        for (int i = ; i < ; i++) {
            builder.append(i);
        }
　　　　  str = builder.tostring();
        end = System.currentTimeMillis();
        System.out.println("耗费时间：" + (end - start))；
    }

}

　　上面的代码中分别将 100000 拼接成一个字符串，记录所需时间，总共运行了三次，第一种直接使用String来拼接三次耗时均在3000毫秒以上，第二种使用StringBuilder方式拼接字符串时三次最高的一次才为15毫秒，通过对比发现使用StringBuilder比String直接拼接性能高了非常多。

　　虽然在拼接大字符串是StringBuilder比String有着明显的优势，但是这并不意味这StringBuilder可以完全替代String，比如在创建比较小的字符串时使用String来创建就足够了，如果还是继续使用StringBuilder来创建，这样反而会对程序的性能有一定的影响，毕竟StringBuilder是一个对象，大量使用的话也会占内存。所以在使用字符串的时候要考虑清楚那种方式比较合理，这样才有助于提高程序的速度。

　　AbstractStringBuilder 常用api

　　AbstractStringBuilder的 常用api跟String常用的api几乎是一样的，而且其内部的实现方法也可以说是大同小异，所以就不再这里赘述了，只要了解了System类的静态方法 arraycopy(Object src, int srcPos,Object dest, int destPos，int length) 即可。里面的几乎所有的方法都用到了这个方法，是该类的核心。

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

　　该方法是将AbstractStringBuilder 的value数组 srcBegin 位置开始 srcEnd - srcBegin 长度的数组 复制到 dst 数组 dstBegin 开始的位置中；

　　

 public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
    {
        if (srcBegin < )
            throw new StringIndexOutOfBoundsException(srcBegin);
        if ((srcEnd < ) || (srcEnd > count))
            throw new StringIndexOutOfBoundsException(srcEnd);
        if (srcBegin > srcEnd)
            throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
　　　　　//value: AbstractStringBuilder 中维护的 char类型数组
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }

大概流程是这样子的：

第一次画图有点难看，将就着看。。。

　　2、AbstractStringBuilder append(String str)

　　该方法是在当前的字符串的后面添加字符串 str。该方法有非常多重载的方法，方法体大都一样，所以其他的就不一一说明了。

public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        //将value数组长度增加 len 个长度，以便后面将字符串放入到数组中
        ensureCapacityInternal(count + len);
        //将字符串 str 放入到 数组 value 中，从数组后面添加
        //count：当前 字符串长度
        str.getChars(, len, value, count);
        //字符串长度增加 len
        count += len;
        return this;
    }

　　3、public AbstractStringBuilder delete(int start, int end)

　　该方法是从当前字符串中的 start位置开始删除字符串删到 end 位置；

 public AbstractStringBuilder delete(int start, int end) {
        /**
         * 删除边界检查
         */
        if (start < )
            throw new StringIndexOutOfBoundsException(start);
        if (end > count)
            end = count;
        if (start > end)
            throw new StringIndexOutOfBoundsException();
        //删除的长度
        int len = end - start;
        if (len > ) {
            //注意：删除方法并不会重新创建一个新的数组，而是在原来的数组中将
            //需要删除的字符移动数组的最后面，然后将字符串的长度减少 len 个长度
            //从而达到删除的效果，这一点需要的注意，我在看代码的花了一点时间才弄明白
            System.arraycopy(value, start+len, value, start, count-end);
            //字符串长度减少 len 个长度
            count -= len;
        }
        return this;
    }

　　举个例子，加入当前的字符串为 abcdefg ， 然后执行删除操作，开始位置start为1，结束为止end为3，count为7，len为2，数组复制的大致流程如下：

值得注意的是，在删除时数组长度并不会减少，这个跟我之前想的有很大的出入，减少的是count的值，即字符串的长度。

　　4、public AbstractStringBuilder replace(int start, int end, String str)

　　该方法是指当前字符串start 到 end 区间的字符串替换成 str 字符串。

 public AbstractStringBuilder replace(int start, int end, String str) {
        if (start < )
            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);
        //根据替换后字符串长度调整 char 数组的大小，避免数组下标溢出异常
        ensureCapacityInternal(newCount);
        //对扩容后的char数组元素进行移动
        System.arraycopy(value, end, value, start + len, count - end);
        //将替换字符串添加到char数组中
        str.getChars(value, start);
        //修改有效字符串的长度
        count = newCount;
        return this;
    }

　　大致的执行流程如下：

　　加入当前的字符串为 abcdefg,start=1，end=3，替换字符串str为 ijk，则，

　　第一步：计算出替换字符串后的长度：int newCount = 7 + 3 - （3-1）= 8；

　　第二步：创建一个newCount 大小的数组，将原数组数据放入到新数组中，新数组多出来的元素默认为 null；

　　上面两个步骤是在 ensureCapacityInternal(newCount) 方法中完成的。

　　第三步：执行System.arraycopy(value, end, value, start + len, count - end)方法，该方法是将替换区间的后段数据移到最后面，顺序保持不变；

　　第四步：将替换字符串放入到新的数组中；

　　第五步：更新count 变量，该变量使用来记录字符串的长度。

　　执行流程图：

　　5、public AbstractStringBuilder insert(int index, char[] str, int offset,int len)

　　该方法是用来向字符串中插入字符串，index：插入位置；str：插入字符数组；offset字符数组开始开始插入位置；len：插入长度。该方法有非常多的重载的方法，操作流程基本一致，无非是传入是数组的话就调用 arraycopy，是字符串则调用String 的 getChars 方法给数组赋值。

public AbstractStringBuilder insert(int index, char[] str, int offset,
                                        int len)
    {
        //检查数组是否越界
        if ((index < ) || (index > length()))
            throw new StringIndexOutOfBoundsException(index);
        if ((offset < ) || (len < ) || (offset > str.length - len))
            throw new StringIndexOutOfBoundsException(
                "offset " + offset + ", len " + len + ", str.length "
                + str.length);
        //数组扩容
        ensureCapacityInternal(count + len);
        //插入点后段后移
        System.arraycopy(value, index, value, index + len, count - index);
        //将插入数组str放入到value中
        System.arraycopy(str, offset, value, index, len);
        //更新长度
        count += len;
        return this;
    }

　　假如value数组为：a,b,c,d,e ，插入数组为：str=f，g，h，index=1,offset=0,len=str.length=3，则count=5,大概执行流程如下：

　　6、public String substring(int start, int end)

public String substring(int start, int end) {
        if (start < )
            throw new StringIndexOutOfBoundsException(start);
        if (end > count)
            throw new StringIndexOutOfBoundsException(end);
        if (start > end)
            throw new StringIndexOutOfBoundsException(end - start);
        //调用String 构造方法截取
        return new String(value, start, end - start);
    }

　　

　　StringBuilder 和 StringBuffer 的区别：

　　1.两者都继承了 AbstractStringBuilder 抽象类。

　　2.前者不是线程安全的，后者是线程安全的，后者在每个方法都添加了 synchronized 关键字，所以它是线程安全的。

　　3.两个都是维护一个可变的字符串；

　　4.在单线程或对安全性不高的程序中，建议使用前者，在多线程中建议使用后者。

　　总结：

　　1、AbstractStringBuilder  和 String 的使用方式如出一辙；

　　2、AbstractStringBuilder 的设计是为了解决String不可变的性质带来的问题的。

　　3、AbstractStringBuilder 不能完全替代String，具体场景具体分析。