StringBuilder和Integer的研读

1.StringBuilder

       总结:StringBuilder与String比起来，StringBuilder增添了一些功能，目前不常用的我也没有深究，只是了解了一下。

1.1

//子类 StringBuilder
//子类可以默认创建一个容量为16的字符数组
public StringBuilder() {
        super(16);
    }
//也可以由程序员根据需求创建一个合适的字符数组
public StringBuilder(int capacity) {
        super(capacity);
    }
//父类AbstractStringBuilder
AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

1.2

//子类中取出字符串中[start,end)中的内容
@Override
public StringBuilder append(CharSequence s, int start, int end) {
        //调用父类中的方法
        super.append(s, start, end);
        //返回内容
        return this;
    }
//父类方法具体实现内容的截取
@Override
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;
        //判断Value这个字符数组能否放下截取的长度
        ensureCapacityInternal(count + len);
        for (int i = start, j = count; i < end; i++, j++)
            value[j] = s.charAt(i);
        count += len;
        return this;
    }
//父类
private void ensureCapacityInternal(int minimumCapacity) {
        //minimumCapacity - value.length<=0，就不用扩充字符数组
        if (minimumCapacity - value.length > 0)
            //minimumCapacity - value.length>0,需要扩充
            expandCapacity(minimumCapacity);
    }
//父类
void expandCapacity(int minimumCapacity) {
        //创建新的容量
        int newCapacity = value.length * 2 + 2;
        //在进行判断newCapacity<minimumCapacity,把newCapacity = minimumCapacity
        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);
    }
//Array类实现字符数组的扩充，现根据新的长度创建新的字符数组，把原来的数组在复制到新数组中，返回新数组
public static char[] copyOf(char[] original, int newLength) {
        char[] copy = new char[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

1.3

//字符数组转换成字符串
@Override
public StringBuilder append(char[] str) {
        super.append(str);
        return this;
    }

1.4

//删除index字符串的内容
@Override
public StringBuilder deleteCharAt(int index) {
        super.deleteCharAt(index);
        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;
    }
//父类
public StringIndexOutOfBoundsException(int index) {
        //不满足条件的返回下标越界
        super("String index out of range: " + index);
    }

1.5

//替换指定位置的字符串[start,end)
@Override
public StringBuilder replace(int start, int end, String str) {
        super.replace(start, end, str);
        return this;
    }

1.6

//返回字符串第一次出现的下标
@Override
public int indexOf(String str) {
        return super.indexOf(str);
    }
//返回字符串最后一次出现的下标
@Override
public int lastIndexOf(String str) {
        return super.lastIndexOf(str);
    }

1.7

//反转字符串
@Override
public StringBuilder reverse() {
        super.reverse();
        return this;
    }
//父类
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;
    }

2.Integer

       总结：Integer丰富数的功能，(1)实现进制之间的转换，(2)Math当中的一些功能直接在Integer中实现，更加的方便；主要举了常用的方法，一些位运算就没有进行深究

2.1. public static final int   MIN_VALUE = 0x80000000;//最小值是(-2)^31

       public static final int   MAX_VALUE = 0x7fffffff;//最大值是(2)^31-1

2.2.

public static final int MIN_RADIX = 2;//当前实现的最小进制为二进制

public static final int MAX_RADIX = 36;//当前实现的进制最大为三十六进制

//该代码的主要功能实现把十进制数转换成其余进制
final static char[] digits = {
        '0' , '1' , '2' , '3' , '4' , '5' ,
        '6' , '7' , '8' , '9' , 'a' , 'b' ,
        'c' , 'd' , 'e' , 'f' , 'g' , 'h' ,
        'i' , 'j' , 'k' , 'l' , 'm' , 'n' ,
        'o' , 'p' , 'q' , 'r' , 's' , 't' ,
        'u' , 'v' , 'w' , 'x' , 'y' , 'z'
    };
public static String toString(int i, int radix) {
        //如果进制小于2或大于36，全部转换成10进制
        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
            radix = 10;

        /* Use the faster version */
        //进制如果是十进制，则直接返回该数字
        if (radix == 10) {
            return toString(i);
        }
        //创建一个容量为33的字符数组
        char buf[] = new char[33];
        //用布尔类型判断i是否小于零
        boolean negative = (i < 0);
        int charPos = 32;
        //如果i>0,把i变成-i
        if (!negative) {
            i = -i;
        }
        //根据进制循环拆数，直到数字比进制大，结束
        while (i <= -radix) {
            //倒着把数字放进数组(从后往前)
            buf[charPos--] = digits[-(i % radix)];
            i = i / radix;
        }
        //把小于进制的数放在当前charPos位置
        buf[charPos] = digits[-i];
        //如果i为负数时，还要在前面加一个负号
        if (negative) {
            buf[--charPos] = '-';
        }
        //最后就是把charPos位置起到字符数组最后的内容输出
        return new String(buf, charPos, (33 - charPos));
    }
    

2.3

//该代码功能实现把数字转换成字符串
public static String toString(int i) {
        //i和Integer最小值比较
        if (i == Integer.MIN_VALUE)
            return "-2147483648";
        //获得数字的长度
        int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
        //创建一个该数字长度的字符数组
        char[] buf = new char[size];
        //调用getChar函数
        getChars(i, size, buf);
        return new String(buf, true);
}
//具体实现获得数字长度的代码
static int stringSize(int x) {
        for (int i=0; ; i++)
            if (x <= sizeTable[i])
                return i+1;
}

2.4

//代码主要实现其余进制转十进制的操作 
public static int parseInt(String s, int radix)
                throws NumberFormatException
    {
        //判断s是否为空
        if (s == null) {
            throw new NumberFormatException("null");
        }
        //判断该进制radix是否比2进制还小
        if (radix < Character.MIN_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " less than Character.MIN_RADIX");
        }
        //判断该进制radix是否比36进制大
        if (radix > Character.MAX_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " greater than Character.MAX_RADIX");
        }

        int result = 0;
        boolean negative = false;
        int i = 0, len = s.length();
        int limit = -Integer.MAX_VALUE;
        int multmin;
        int digit;
        //实现十进制的功能，转换成十进制数
        if (len > 0) {
            char firstChar = s.charAt(0);
            if (firstChar < '0') { // Possible leading "+" or "-"
                if (firstChar == '-') {
                    negative = true;
                    limit = Integer.MIN_VALUE;
                } else if (firstChar != '+')
                    throw NumberFormatException.forInputString(s);

                if (len == 1) // Cannot have lone "+" or "-"
                    throw NumberFormatException.forInputString(s);
                i++;
            }
            multmin = limit / radix;
            while (i < len) {
                // Accumulating negatively avoids surprises near MAX_VALUE
                digit = Character.digit(s.charAt(i++),radix);
                if (digit < 0) {
                    throw NumberFormatException.forInputString(s);
                }
                if (result < multmin) {
                    throw NumberFormatException.forInputString(s);
                }
                result *= radix;
                if (result < limit + digit) {
                    throw NumberFormatException.forInputString(s);
                }
                result -= digit;
            }
        } else {
            throw NumberFormatException.forInputString(s);
        }
        return negative ? result : -result;
    }

2.5

//主要实现两个对象的数是否相等
public boolean equals(Object obj) {
        //如果两个数是属于同一类型
        if (obj instanceof Integer) {
            //比较两个数的地址
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

2.6

//该代码主要实现两个数的大小比较
public static int compare(int x, int y) {
        //如果x<y返回-1;x==y返回0;x>y返回1
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }

2.7

//该代码主要实现两个数的相加
public static int sum(int a, int b) {
        return a + b;
    }

2.8

//该代码主要实现返回两个数中较大的  
public static int max(int a, int b) {
        return Math.max(a, b);
    }

2.9

//该代码主要实现返回两个数中较小的 
public static int min(int a, int b) {
        return Math.min(a, b);
    }