Java源码阅读笔记-Integer

所继承的类Number，所实现的接口Compareable

public final class Integer extends Number implements Comparable

    Number是一个抽象类，用来表示数字（废话）。继承这个类需要实现intValue，doubleValue等抽象方法以实现各种类型的数值相互转换，比如int转double，就需要将doubleValue实现为{return (double)value;}。

    Compareable是用于比较的接口（又是废话）。主要用于排序。

为什么最小值MIN_VALUE是0x80000000，比最大值MAX_VALUE：0x7fffffff还要大一位？

@Native public static final int   MIN_VALUE = 0x80000000;
@Native public static final int   MAX_VALUE = 0x7fffffff;

    先将这两个16进制转为二进制看：MIN:100000……  MAX:0111111……。

    整数在JVM中是以补码的形式表示的，首位表示正负，其余位标示数值。大家知道如果使用原码表示，那么就有正零（0000……）和负零（10000……）之分，int值一共32位那么原码能标示的最小值就是-(2^31 - 1);而使用补码表示，零只占其中一个数组，多出来的一个数值可以表示最小值，那么原码所能表示的最小值就能比原码表示的更加小一位，即-(2^31) = -2147483648。MAX_VALUE就很好理解了，第一位为零代表整数，其余都为一，那么就是+2^31-1；

数字转字符串toString()相关的主要方法

public static String toString(int i) {
        if (i == Integer.MIN_VALUE)
            return "-2147483648";
        int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
        char[] buf = new char[size];
        getChars(i, size, buf);
        return new String(buf, true);
    }

    toString(int i):如上文所述，最小值使用一个特殊值表示的，所以需要特殊对待，如果i是最小值，那么直接返回“-2147483648”。如果i是负值就意味着字符串长度要比绝对值的位数多一位，即符号位。然后使用getchars()得到每一位数字对应的字符，最后转化为String返回。

static void getChars(int i, int index, char[] buf) {
        int q, r;
        int charPos = index;
        char sign = 0;

        if (i < 0) {
            sign = '-';
            i = -i;
        }

        // Generate two digits per iteration
        while (i >= 65536) {
            q = i / 100;
        // really: r = i - (q * 100);
            r = i - ((q << 6) + (q << 5) + (q << 2));
            i = q;
            buf [--charPos] = DigitOnes[r];
            buf [--charPos] = DigitTens[r];
        }

        // Fall thru to fast mode for smaller numbers
        // assert(i <= 65536, i);
        for (;;) {
            q = (i * 52429) >>> (16+3);
            r = i - ((q << 3) + (q << 1));  // r = i-(q*10) ...
            buf [--charPos] = digits [r];
            i = q;
            if (i == 0) break;
        }
        if (sign != 0) {
            buf [--charPos] = sign;
        }
    }

    数字转字符数组核心方法getChars(int i,int index,char[] buf);i是数据源，index是结果长度，buf是用于存储结果的变量。开头先处理负数，对负数记下符号位并取反。然后接下来的逐位解析与预想中的不同，如果让我来写，一定是从右到左逐位%10取余，然后转换成对应的字符。但是明显这里的处理更复杂，其实不同点在于使用了乘法再减法以两个数字为单位进行解析(>>n运算符表示向左移动并填充0，即乘以2^n，此处的(q << 6) + (q << 5) + (q << 2)其实就是q*100）,这是因为做乘法的速度远大于除法。不得不说真是大神手笔。

字符串转数字parseInt(String s,int radix)相关的主要方法

    与toString相比还是较简单的，radix表示进制，s代表需要转换的字符串。首先对首位可能出现的“+”，“-”进行了判断，然后逐位从左到右转换成数字digit（包括对abcdef这些16进制数的转换），result乘以进制数后减去digit（不是加上，也就是说Result是越算越小的，当然最后会乘以-1以得到正确值，推测可能是因为减法比加法速度快），遍历完所有字符，结果也就得出来了。

public static int parseInt(String s, int radix)
                throws NumberFormatException
    {
        /*略去部分代码*/
        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);
                /*略去部分代码*/
                result *= radix;
                
                result -= digit;
            }
        } else {
            throw NumberFormatException.forInputString(s);
        }
        return negative ? result : -result;
    }

   

decode与parseInt的区别

    parseInt用于将字符串(十进制)转为数字，而decode可以对不同进制的数字进行分析。

Integer缓冲区

   为了提升效率，Integer对范围[-128,127]的数字做了缓冲，如果初始化一个Integer的值在这之间，那么可以直接使用缓冲区里已有的实例，否则将会新建一个实例。 

equals()与hashcode()的重写

public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

public int hashCode() {
        return Integer.hashCode(value);
    }

    equals被重写为返回两个integer是否拥有相同的value，hashcode被重写为返回Integer的value。这就意味着：只要两个Integer内含的value相等，无论两者是否引用了同一个对象，使用equals作比较得出的结果一定是true。

    而对于==的使用，上文提到由于缓冲区的存在，只要在[-128,127]之间的数字，无论如何新建对象都引用于此，所以只要值相同地址也就相同,==返回的当然是true。在这范围之外的数字就不一样了，比如两次创建的Integer(133),地址并不相同,==自然返回false。