JDK1.8源码(二)——java.lang.Integer类

一、初识

1、介绍

　　int 是Java八大基本数据类型之一，占据 4 个字节，范围是 -2^31~2^31 - 1，即 -2147483648~2147483647。而 Integer 是 int 包装类。
　　Integer 是类，默认值为null；int是基本数据类型，默认值为0。
　　Integer 表示的是对象，用一个引用指向这个对象，而 int 是基本数据类型，直接存储数值。

二、自动装箱和拆箱

1、案例

　　先看如下代码执行结果：

int i1 = 59;

Integer i2 = 59;

Integer i3 = new Integer(59);
Integer i4 = new Integer(59);

Integer i5 = Integer.valueOf(59);
Integer i6 = Integer.valueOf("59");

System.out.println("----" + (i1 == i2)); // true
System.out.println("----" + (i1 == i3)); // true
System.out.println("----" + (i1 == i4)); // true
System.out.println("----" + (i1 == i5)); // true
System.out.println("----" + (i1 == i6)); // true

System.out.println("----" + (i2 == i3)); // false
System.out.println("----" + (i2 == i4)); // false
System.out.println("----" + (i2 == i5)); // true
System.out.println("----" + (i2 == i6)); // true

System.out.println("----" + (i3 == i4)); // false
System.out.println("----" + (i3 == i5)); // false
System.out.println("----" + (i3 == i6)); // false

System.out.println("----" + (i4 == i5)); // false
System.out.println("----" + (i4 == i6)); // false

System.out.println("----" + (i5 == i6)); // true

　　结论：先记下上述结果，后续会详细解释。
　　①基本数据类型 int 和其他任何形式创建的 Integer 比较都是true；
　　②Integer 表示的是对象，它是一个引用，存储的是对象在堆空间的地址。如图：

　　所以：int 的比较结果不难理解（后面还会解释），而对象的比较应该全是 false，因为他们创建了不同的对象，地址自然是不同的。那这里 i2 == i5，i2 == i6，i5 == i6 为什么是true呢？
　　因为 Integer 的自动拆箱和装箱原理，以及缓存机制。
　　自动拆箱和装箱是 JDK1.5 以后才有的功能，也是 Java 众多的语法糖之一，它的执行是在编译期，会根据代码的语法，在生成class文件的时候，决定是否进行拆箱和装箱动作。

2、自动拆箱

　　将 Integer 类表示的数据赋值给基本数据类型int，就执行了自动拆箱。

Integer a = new Integer(59);
int m = a;

　　反编译生成的class文件，上述表达式等价于：

Integer a = new Integer(59);
int m = a.intValue();

　　所以，在上述代码比较时，与 int 类型的比较都是true，因为包装类Integer会自动拆箱为数值型，数值的比较当然是true。等价于：

System.out.println("----" + (i1 == i2.intValue())); // true
System.out.println("----" + (i1 == i3.intValue())); // true
System.out.println("----" + (i1 == i4.intValue())); // true
System.out.println("----" + (i1 == i5.intValue())); // true
System.out.println("----" + (i1 == i6.intValue())); // true

3、自动装箱

　　一般地，创建对象是通过 new 关键字，比如：

Object obj = new Object();

　　对于 Integer 类，可以：

Integer a = 59;

　　反编译生成的class文件，上述表达式等价于：

Integer a = Integer.valueOf(59);

　　它其实等价的创建了一个对象，这种语法帮我们完成了而已。既然是对象，那么存储的就是引用，也就不难理解上述代码那些为 false 的结果。
　　那为什么 i2 == i5，i2 == i6，i5 == i6 是 true 呢？

4、缓存机制（新特性）

　　前面我们知道

Integer a = 59; 等价于 Integer a = Integer.valueOf(59);

　　查看一下valueOf()方法的源码，它有三个重载的方法。
　　源码示例：Integer.valueOf()

public static Integer valueOf(String s) throws NumberFormatException {
    return Integer.valueOf(parseInt(s, 10));
}

public static Integer valueOf(int i) {
    if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
        return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
    return new Integer(i);
}

　　很容易看到，这里 -128 <= i <= 127，是直接 return 了 IntegerCache 里的对象，并没有新建对象。
　　数值在byte（-128~127）范围内，如果该数值已存在，则不会再开辟新的空间，会使用常量池，指向了同一个 Integer 对象。也就不难理解 i2 == i5，i2 == i6，i5 == i6 是 true。如果将上述代码的数值改为128，再执行，除了 int 的比较是true，其他就都是 false 了。读者可自行验证。

　　结论：
　　①int 型比较，由于自动拆箱，比较结果都是true；
　　②Integer 比较，由于自动装箱和缓存。数值在 -128~127 ，为true，否则为false。注意：如果通过 new 关键字新建的对象，是不存在缓存的概念的，不管数值的大小，都是 false。

三、类源码

1、介绍

　　源码示例：类声明

 * @author  Lee Boynton
 * @author  Arthur van Hoff
 * @author  Josh Bloch
 * @author  Joseph D. Darcy
 * @since JDK1.0
 */
public final class Integer extends Number implements Comparable<Integer> {
}

　　Integer 类在JDK1.0的时候就有了，它是一个类，是 int 基本数据类型的封装类，是用 final 声明的常量类，不能被任何类所继承，它继承了 Number 类和实现了 Comparable 接口。
　　Number 类是一个抽象类，8 中基本数据类型的包装类除了Character 和 Boolean 没有继承该类外，其他的都继承了 Number 类，该类的方法用于各种数据类型的转换。
　　Comparable 接口就一个 compareTo 方法，用于元素之间的比较。
　　官方文档：

　　https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html

2、类构造器

　　源码示例：类构造器

public Integer(int value) {
    this.value = value;
}

public Integer(String s) throws NumberFormatException {
    // 其中s表示我们需要转换的字符串，10表示以十进制输出，默认也是10进制
    this.value = parseInt(s, 10);
}


public static int parseInt(String s, int radix)
            throws NumberFormatException
{

    // 如果转换的字符串为null，直接抛出数字格式异常
    if (s == null) {
        throw new NumberFormatException("null");
    }

    // 如果转换的radix(默认是10)<2 则抛出数字格式异常，因为进制最小是 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(); //len是待转换字符串的长度
    int limit = -Integer.MAX_VALUE;
    int multmin;
    int digit;

    if (len > 0) {
        char firstChar = s.charAt(0);
        // 主要判断第一个字符是"+"或者"-"，因为这两个字符的 ASCII码都小于字符'0'
        if (firstChar < '0') { // Possible leading "+" or "-"
            if (firstChar == '-') { // 如果第一个字符是'-'
                negative = true;
                limit = Integer.MIN_VALUE;
            } else if (firstChar != '+') // 如果第一个字符不是'+'
                throw NumberFormatException.forInputString(s);

            // 待转换字符长度是1，不能是单独的"+"或者"-"，否则抛出异常
            if (len == 1) // Cannot have lone "+" or "-"
                throw NumberFormatException.forInputString(s);
            i++;
        }
        multmin = limit / radix;
        
        //通过循环，将字符串除掉第一个字符之后，根据进制不断相乘在相加得到一个正整数
        //比如 parseInt("2abc",16) = 2*16的3次方+10*16的2次方+11*16+12*1 
        //parseInt("123",10) = 1*10的2次方+2*10+3*1 
        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 {
        // 如果待转换字符串长度小于等于0，直接抛出异常
        throw NumberFormatException.forInputString(s);
    }
    //根据第一个字符得到的正负号，在结果前面加上符号
    return negative ? result : -result;
}

3、toString()方法

　　这个方法有三个重载方法，能返回一个整型数据所表示的字符串形式。toString(int) 方法内部调用了 stringSize() 和 getChars() 方法。
　　源码示例：stringSize()

final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                                  99999999, 999999999, Integer.MAX_VALUE };

// Requires positive x
static int stringSize(int x) {
    for (int i=0; ; i++)
        if (x <= sizeTable[i])
            return i+1;
}

　　stringSize() 它是用来计算参数 i 的位数，也就是转成字符串之后的字符串的长度，内部结合一个已经初始化好的int类型的数组sizeTable来完成这个计算。注意，负数包含符号位，所以对于负数的位数是 stringSize(-i) + 1。

　　源码示例：getChars()

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

    if (i < 0) {
        sign = '-'; // sign记下它的符号"-"
        i = -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) {
        // 将 sign 的值放在char数组的首位。
        buf [--charPos] = sign;
    }
}

　　i：被初始化的数字。
　　index：这个数字的长度（包括负数的符号"-"）。
　　buf：字符串的容器，一个char型数组。

4、equals(Object obj)方法

　　源码示例：equals()

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

5、hashCode()方法

　　源码示例：hashCode()

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

public static int hashCode(int value) {
    return value;
}

　　直接返回其 int 类型的值作为哈希值。

6、parseInt()方法

　　这个方法有两个重载方法，能将字符串转换成整型输出。构造器中已经调用了parseInt()方法。

7、compareTo()/compare()方法

　　源码示例：

public int compareTo(Integer anotherInteger) {
    return compare(this.value, anotherInteger.value);
}

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

　　这个源码不难读懂。值得注意的是，compareTo()方法是实现 Comparable 接口后，需要实现的方法。而 compare 是 Integer 内自己定义的一个方法。

四、其他

public static void main(String[] args) {
    Integer i = 42;
    Long j = 42L;
    Double k = 42.0;

    System.out.println(i == j); // java: 不可比较的类型: java.lang.Integer和java.lang.Long
    System.out.println(i == k); // java: 不可比较的类型: java.lang.Integer和java.lang.Double
    System.out.println(j == k); // java: 不可比较的类型: java.lang.Long和java.lang.Double

    System.out.println(i.equals(j)); // false
    System.out.println(i.equals(k)); // false
    System.out.println(j.equals(k)); // false

    System.out.println(j.equals(42L)); // true
}