JDK1.8源码阅读（2）--AbstractStringBuilder/StringBuffer/StringBuilder/Boolean

JDK1.8源码阅读（2）–AbstractStringBuilder/StringBuffer/StringBuilder/Boolean

包括AbstractStringBuilder/StringBuffer/StringBuilder/Boolean

一.AbstractStringBuilder

抽象类，类图：

继承了2个接口，一个是CharSequence，前面一章讲过，还有个是Appendable，下面讲讲这个：
这是一个添加字符序列的接口，代表对象具有添加字符序列的能力
Appendable append(CharSequence csq)：向该对象添加一个字符序列
Appendable append(CharSequence csq, int start, int end)：向该对象添加一个指定范围的字符序列
Appendable append(char c)：向该对象添加一个字符
接下来讲讲这个抽象类：
成员变量：
char[] value：以字符数组形式储存字符序列
int count：当前所包含的字节数量
方法：
1.AbstractStringBuilder()
空参构造
2.AbstractStringBuilder(int capacity)
指定容量的构造，内容是空的

    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    } 

3.public int length()
得到ASB的字符数量（实际长度）

    public int length() {
        return count;
    }

4.public int capacity()
得到ASB目前的容量（可以储存的长度）

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

5.public void ensureCapacity(int minimumCapacity)
确保ASB内部拥有最小的容量

    public void ensureCapacity(int minimumCapacity) {
        if (minimumCapacity > 0)
            ensureCapacityInternal(minimumCapacity);
    }

6.private void ensureCapacityInternal(int minimumCapacity)
私有方法，如果现在ASB的容量小于最小容量，将会对ASB进行扩容。

    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0)
            expandCapacity(minimumCapacity);
    }

7.void expandCapacity(int minimumCapacity)
protected方法，就ASB进行扩容操作。

    void expandCapacity(int minimumCapacity) {
    //先扩容到原来的两倍加2.
        int newCapacity = value.length * 2 + 2;
        //如果扩容后还是小于要求的最小容量，就把最小容量当做扩容后的容量
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        value = Arrays.copyOf(value, newCapacity);
    }

8.public void trimToSize()
如果要求的容量小于现在的容量，就将现在的ASB进行裁剪

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

9.public void setLength(int newLength)
将ASB设置新的长度，将多出的位置填充0

    public void setLength(int newLength) {
        if (newLength < 0)
            throw new StringIndexOutOfBoundsException(newLength);
        ensureCapacityInternal(newLength);

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

        count = newLength;
    }

10.public char charAt(int index)
按照索引找到ASB中的元素

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

11.public int codePointAt(int index)
按照索引找到ASB中元素所对应的编码
12.public int codePointBefore(int index)
按照索引找到ASB中前面一个元素对应的编码
13.public int codePointCount(int beginIndex, int endIndex)
统计指定范围内有多少个unicode字符
14.public int offsetByCodePoints(int index, int codePointOffset)
返回从index偏移codePointOffset个Unicode符号后新的索引值，codePointOffset的正负决定了偏移方向
15.public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将ASB[srcBegin, srcEnd)内的字节批量转换为char后存入dst（从dstBegin开始存）
16.public void setCharAt(int index, char ch)
将索引为index处的字符改成ch
17.public AbstractStringBuilder append(Object obj)
将obj转成字符串后与原来的字符串相加
18.public AbstractStringBuilder append(String str)
将str添加到原来的ASB中

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

19.public AbstractStringBuilder append(StringBuffer sb)
将StringBuffer对象添加到ASB中

    public AbstractStringBuilder append(StringBuffer sb) {
        if (sb == null)
            return appendNull();
        int len = sb.length();
        ensureCapacityInternal(count + len);
        sb.getChars(0, len, value, count);
        count += len;
        return this;
    }

20.AbstractStringBuilder append(AbstractStringBuilder asb)
将参数ASB对象添加到ASB中

    AbstractStringBuilder append(AbstractStringBuilder asb) {
        if (asb == null)
            return appendNull();
        int len = asb.length();
        ensureCapacityInternal(count + len);
        asb.getChars(0, len, value, count);
        count += len;
        return this;
    }

21.public AbstractStringBuilder append(CharSequence s)
将字符序列添加到ASB中

    public AbstractStringBuilder 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());
    }

22.private AbstractStringBuilder appendNull()
将‘null’字符加扩容后的ASB中的最后四位

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

23.public AbstractStringBuilder append(CharSequence s, int start, int end)
将字符序列指定范围中的字符加入ASB中

    public AbstractStringBuilder append(CharSequence s, int start, int end) {
        if (s == null)
            s = "null";
        if ((start < 0) || (start > end) || (end > s.length()))
            throw new IndexOutOfBoundsException(
                "start " + start + ", end " + end + ", s.length() "
                + s.length());
        int len = end - start;
        ensureCapacityInternal(count + len);
        for (int i = start, j = count; i < end; i++, j++)
            value[j] = s.charAt(i);
        count += len;
        return this;
    }

24.public AbstractStringBuilder append(char[] str)
将字符数组加入ASB中
25.public AbstractStringBuilder append(char str[], int offset, int len)
将字符数组指定范围内的字符加入ASB中
26.public AbstractStringBuilder append(boolean b)
如果是true，就把‘true’加入到ASB中；如果是false，就把‘false’加入到ASB中

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

27.public AbstractStringBuilder append(char c)
复写了接口中的append方法，往ASB中添加一个字符
28.public AbstractStringBuilder append(int i)
ASB末尾添加一个int值的字符串序列

    public AbstractStringBuilder append(int i) {
        if (i == Integer.MIN_VALUE) {
            append("-2147483648");
            return this;
        }
        int appendedLength = (i < 0) ? Integer.stringSize(-i) + 1
                                     : Integer.stringSize(i);
        int spaceNeeded = count + appendedLength;
        ensureCapacityInternal(spaceNeeded);
        Integer.getChars(i, spaceNeeded, value);
        count = spaceNeeded;
        return this;
    }

29.public AbstractStringBuilder append(long l)
ASB末尾添加一个long值的字符串

    public AbstractStringBuilder append(long l) {
        if (l == Long.MIN_VALUE) {
            append("-9223372036854775808");
            return this;
        }
        int appendedLength = (l < 0) ? Long.stringSize(-l) + 1
                                     : Long.stringSize(l);
        int spaceNeeded = count + appendedLength;
        ensureCapacityInternal(spaceNeeded);
        Long.getChars(l, spaceNeeded, value);
        count = spaceNeeded;
        return this;
    }

30.public AbstractStringBuilder append(float f)
ASB末尾添加一个float值的字符串
31.public AbstractStringBuilder append(double d)
ASB末尾添加一个double值的字符串
32.public AbstractStringBuilder delete(int start, int end)
将ASB中从start到end的字符向后移动end-start的距离，再减小ASB的容量，看起来像是把start到end的字符删去了。

    public AbstractStringBuilder delete(int start, int end) {
        if (start < 0)
            throw new StringIndexOutOfBoundsException(start);
        if (end > count)
            end = 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;
        }
        return this;
    }

33.public AbstractStringBuilder appendCodePoint(int codePoint)
向ASB末尾添加一个由Unicode码点值表示的char的字符串序列

    public AbstractStringBuilder appendCodePoint(int codePoint) {
        final int count = this.count;

        if (Character.isBmpCodePoint(codePoint)) {
            ensureCapacityInternal(count + 1);
            value[count] = (char) codePoint;
            this.count = count + 1;
        } else if (Character.isValidCodePoint(codePoint)) {
            ensureCapacityInternal(count + 2);
            Character.toSurrogates(codePoint, value, count);
            this.count = count + 2;
        } else {
            throw new IllegalArgumentException();
        }
        return this;
    }

34.public AbstractStringBuilder deleteCharAt(int index)
将ASB中位于索引index处的字符删去。
35.public AbstractStringBuilder replace(int start, int end, String str)
将ASB中位于start和end之间的字符用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);
        ensureCapacityInternal(newCount);

        System.arraycopy(value, end, value, start + len, count - end);
        str.getChars(value, start);
        count = newCount;
        return this;
    }

36.public String substring(int start)
从start索引处开始生成子字符串

    public String substring(int start) {
        return substring(start, count);
    }

37.public CharSequence subSequence(int start, int end)
指定范围生成子字符序列
38.public String substring(int start, int end)
指定范围生成子字符串，底层就是用的String的构造方法

    public String substring(int start, int end) {
        if (start < 0)
            throw new StringIndexOutOfBoundsException(start);
        if (end > count)
            throw new StringIndexOutOfBoundsException(end);
        if (start > end)
            throw new StringIndexOutOfBoundsException(end - start);
        return new String(value, start, end - start);
    }

39.public AbstractStringBuilder insert(int index, char[] str, int offset,int len)
在字符数组的指定范围插入到ASB索引为index处。

    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);
        ensureCapacityInternal(count + len);
        System.arraycopy(value, index, value, index + len, count - index);
        System.arraycopy(str, offset, value, index, len);
        count += len;
        return this;
    }

40.public AbstractStringBuilder insert(int offset, Object obj)
将Object转成String类后插入ASB。
41.public AbstractStringBuilder insert(int offset, String str)
将String类插入ASB中

    public AbstractStringBuilder insert(int offset, String str) {
        if ((offset < 0) || (offset > length()))
            throw new StringIndexOutOfBoundsException(offset);
        if (str == null)
            str = "null";
        int len = str.length();
        ensureCapacityInternal(count + len);
        System.arraycopy(value, offset, value, offset + len, count - offset);
        str.getChars(value, offset);
        count += len;
        return this;
    }

42.public AbstractStringBuilder insert(int offset, char[] str)
将字符数组插入到ASB中。

    public AbstractStringBuilder insert(int offset, char[] str) {
        if ((offset < 0) || (offset > length()))
            throw new StringIndexOutOfBoundsException(offset);
        int len = str.length;
        ensureCapacityInternal(count + len);
        System.arraycopy(value, offset, value, offset + len, count - offset);
        System.arraycopy(str, 0, value, offset, len);
        count += len;
        return this;
    }

43.public AbstractStringBuilder insert(int dstOffset, CharSequence s)
将字符序列插入到ASB中
44.public AbstractStringBuilder insert(int dstOffset, CharSequence s,int start, int end)
将字符序列的指定范围插入到ASB索引为dstOffset处。
45.public AbstractStringBuilder insert(int offset, boolean b)
将布尔值的String表达插入到ASB索引为offset处
46.public AbstractStringBuilder insert(int offset, char c)
将字符c转换成字符串后插入到ASB索引为offset处
47.public AbstractStringBuilder insert(int offset, int i)
将int值i转换成字符串后插入到ASB索引为offset处
48.public AbstractStringBuilder insert(int offset, long l)
将long值l转换成字符串后插入到ASB索引为offset处
49.public AbstractStringBuilder insert(int offset, float f)
将float值f转换成字符串后插入到ASB索引为offset处
50.public AbstractStringBuilder insert(int offset, double d)
将double值d转换成字符串后插入到ASB索引为offset处
51.public int indexOf(String str, int fromIndex)
返回ABS中从fromIndex开始第一个与str匹配的索引值

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

52.public int lastIndexOf(String str)
返回ABS中最后一个与str匹配的索引值
53.public int lastIndexOf(String str, int fromIndex)
返回ABS中从fromIndex开始往前最后一个与str匹配的索引值
54.public AbstractStringBuilder reverse()
翻转ASB

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

55.private void reverseAllValidSurrogatePairs()
私有方法，主要帮助54方法中处理有些字符超过了unicode编码

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

56.public abstract String toString()
抽象类，需要被继承类去复写，每一个继承类由自己的toString方法
57.final char[] getValue()
不能被复写的方法，返回的是value数组

二.StringBuffer类

类图：

继承了抽象类ASB，接口Serializable和CharSequence。
首先StringBuffer是个final类，不可以被继承。
成员变量：
private transient char[] toStringCache
用transient关键字标记的成员变量不参与序列化过程，调用toString()后生成的缓存，用于存储ASB中的字符序列。每次更改ASB都会清理缓存
static final long serialVersionUID = 3388685877147921107L;序列号
方法：
1.public StringBuffer()
调用父类方法构造个容量为16的ASB

    public StringBuffer() {
        super(16);
    }

2.public StringBuffer(int capacity)
同样也可以自己指定容量。
3.public StringBuffer(String str)
创建一个StringBuffer对象，并且将str赋值

    public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }

4.public StringBuffer(CharSequence seq)
创建一个StringBuffer对象，并且将seq赋值
5.public synchronized int length()
加锁地获取字符长度
6.public synchronized int capacity()
加锁地获得最大可容纳字符长度
7.public synchronized void ensureCapacity(int minimumCapacity)
确保最大可容纳字符长度大于参数给的最小容量
8.public synchronized void setLength(int newLength)
加锁的给ASB设置新的长度，设置前先清空ASB缓存。
9.public synchronized char charAt(int index)
加锁的根据索引找出ASB中的字符
10.public synchronized int codePointAt(int index)
加锁的根据索引找出ASB中的字符编码
11.public synchronized int codePointBefore(int index)
加锁的根据索引前一位找出ASB中的字符编码
12.public synchronized int codePointCount(int beginIndex, int endIndex)
加锁的根据begin和end找出指定区域内包含多少个unicode符号
13.public synchronized int offsetByCodePoints(int index, int codePointOffset)
加锁地返回从index偏移codePointOffset个Unicode符号后新的索引值，codePointOffset的正负决定了偏移方向
14. public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,int dstBegin)
加锁地将ASB一定范围内的字符复制到dst从dstBegin开始的位置
15.public synchronized void setCharAt(int index, char ch)
加锁的设置ASB索引为index处的值
16.public synchronized StringBuffer append(Object obj)
加锁地将参数转化为String后添加到ASB后面，修改前要清空ASB缓存。
17.public synchronized StringBuffer append(String str)
加锁地将str添加到ASB后面，修改前要清空ASB缓存。
18.public synchronized StringBuffer append(StringBuffer sb)
加锁地将sb添加到ASB后面，修改前要清空ASB缓存。
19.synchronized StringBuffer append(AbstractStringBuilder asb)
加锁地将asb添加到ASB后面，修改前要清空ASB缓存。
20.public synchronized StringBuffer append(CharSequence s)
加锁地将字符序列s添加到ASB后面，修改前要清空ASB缓存。
21.public synchronized StringBuffer append(CharSequence s, int start, int end)
加锁地将字符序列s从start到end添加到ASB后面，修改前要清空ASB缓存。
22.public synchronized StringBuffer append(char[] str)
加锁地将字符数组str添加到ASB后面，修改前要清空ASB缓存。
23.public synchronized StringBuffer append(char[] str, int offset, int len)
加锁地将字符数组str，从offset开始长度为len的部分添加到ASB后面，修改前要清空ASB缓存。
24.public synchronized StringBuffer append(boolean b)
加锁地将布尔值的string形式添加到ASB后面，修改前要清空ASB缓存。
25.public synchronized StringBuffer append(char c)
加锁地将字符c添加到ASB后面，修改前要清空ASB缓存。
。。。。。接下来很多方法都是复写ASB中的方法，这里不再赘述
toString方法，将ASB缓存中取出，如果ASB缓存不存在，就直接读取ASB中的数据

    public synchronized String toString() {
        if (toStringCache == null) {
            toStringCache = Arrays.copyOfRange(value, 0, count);
        }
        return new String(toStringCache, true);
    }

三.StringBuilder类

类图：

继承关系跟StringBuffer类似。
成员变量只有一个序列化代码。
其余方法与StringBuilder类似，唯一区别就是不需要加锁，修改ASB后也不需要清空缓存。

四.boolean类

类图：

继承了序列化接口和Comparable接口（内比较器）。
成员变量和方法：

成员变量：
1.public static final Boolean TRUE = new Boolean(true)
2.public static final Boolean FALSE = new Boolean(false)
3.public static final Class TYPE = (Class) Class.getPrimitiveClass(“boolean”);
4.private final boolean value;当前类包装的值
5.private static final long serialVersionUID = -3665804199014368530L;序列号

方法：
1.public Boolean(boolean value)构造函数，参数就是boolean形式
2.public Boolean(String s)构造函数，参数是String形式
3.public static boolean parseBoolean(String s)
将字符串转变成boolean形式，String只有等于忽略大小的‘true’，才会返回boolean值true
4.public boolean booleanValue()得到成员变量value值
5.public static Boolean valueOf(boolean b)装箱
6.public static Boolean valueOf(String s)先转变成boolean，再装箱
7.public static String toString(boolean b)
静态方法，boolean形式转String

    public static String toString(boolean b) {
        return b ? "true" : "false";
    }

8.public String toString()实例方法
9.public int hashCode()返回哈希值
10.public static int hashCode(boolean value)根据类包装的值生成哈希值
true的时候是1231，false的时候是1237
11.public boolean equals(Object obj)
先判断obj类型是否是Boolean再进行比较
12.public static boolean getBoolean(String name)
从系统属性中获取值
13.public int compareTo(Boolean b)
复写了接口Comparable
14.public static int compare(boolean x, boolean y)
比较方法，返回x-y

    public static int compare(boolean x, boolean y) {
        return (x == y) ? 0 : (x ? 1 : -1);
    }

15.public static boolean logicalAnd(boolean a, boolean b)逻辑与
16.public static boolean logicalOr(boolean a, boolean b)逻辑或
17.public static boolean logicalXor(boolean a, boolean b)逻辑异或