java.lang.Integer源码分析

1. 描述

API：int的包装类型，内部包含了一个int字段。
关键字段：

private final int value; //和String类似，Integer内部也是存储了一个final的value
  
public static final int MIN_VALUE = 0x80000000;  //Integer最小值-2^31

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

2. 构造函数

第一种直接赋值：传入的int直接赋值给value（代码略）。
第二种传入String然后转成int：

   public Integer(String s) throws NumberFormatException {
       this.value = parseInt(s, 10);  //10是进制
   }
   public static int parseInt(String s, int radix) throws NumberFormatException{
       if (s == null) {
           throw new NumberFormatException("null");
       }
       //进制限制数最小2
       if (radix < Character.MIN_RADIX) {
           throw new NumberFormatException("radix " + radix +
                                           " less than Character.MIN_RADIX");
       }
       //进制限制数最大36(0-9、a-z)
       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) {
           //拿第一个字符，如果是负号标记，如果是正号或数字跳过，否则抛异常，下标推后1
           char firstChar = s.charAt(0);
           //跳过第一位是数字的情况
           if (firstChar < '0') {
               if (firstChar == '-') {
                   //正负的标记字段
                   negative = true;                 
                   limit = Integer.MIN_VALUE;
               } else if (firstChar != '+')         
                   throw NumberFormatException.forInputString(s);
               if (len == 1)
                   throw NumberFormatException.forInputString(s);
               i++;     
           }
           multmin = limit / radix;
           //计算方法是从最高位到最低位循环，每次乘10然后相加，如十进制的"123"，result初始化0
           //第一次循环"1" -> 1，result = result * 10 + 1 = 1
           //第二次循环"2" -> 2，result = result * 10 + 2 = 12
           //第三次循环"3" -> 3，result = result * 10 + 3 = 123，判断符号返回result
           while (i < len) {
               //根据ASCII码换算出数字，如10进制'0'~'9'->0~9，16进制'0'~'f'->0~16，超出返回-1
               digit = Character.digit(s.charAt(i++),radix);
               if (digit < 0) {
                   throw NumberFormatException.forInputString(s);
               }
               //结果不能越界
               if (result < multmin) {
                   throw NumberFormatException.forInputString(s);
               }
               //result乘进制数
               result *= radix;
               if (result < limit + digit) {
                   throw NumberFormatException.forInputString(s);
               }
               //每次循环给最后一位赋值
               result -= digit;
           }
       } else {
           throw NumberFormatException.forInputString(s);
       }
       //根据正负返回结果
       return negative ? result : -result;
   }

流程总结：先判断第一位是正负，做标记，然后从高位开始到低位循环，每位都单独转换成int，再把之前结果乘10然后相加，最后计算正负得出结果。

3. equals()

先用instanceof判断类型关系，然后用"=="判断值是否相等（代码很简单略过）

4. hashCode()

integer的重写了hashCode()直接返回value字段本身

5. 自动装箱和拆箱

基本类型和包装类型相互转换时，在编译阶段会进行自动装箱、拆箱的优化

//编译前
Integer a = 128;

Integer b = new Integer(128);
int m = b;

通过javap -c反编译仔细观察一下

反编译.jpg

   //更直观的看出编译时到底做了什么优化
   Integer a = Integer.valueOf(128);  //int -> Integer 自动装箱
   
   Integer b = new Integer(129);
   int m = b.intValue();   //Integer -> int 自动拆箱

Integer.valueOf() - 自动装箱

static final Integer cache[];

//-128~127都取是缓存的Integer对象，超出范围就new一个新的
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)        
        return IntegerCache.cache[i + (-IntegerCache.low)];    
    return new Integer(i);
}

intValue() - 自动拆箱

 //Integer转int就是直接返回value
 public int intValue() {    
     return value;
 }

借助System.identityHashCode()进行测试验证一下，为什么使用identityHashCode()跳转https://www.jianshu.com/p/7f0893577acf

//原代码
Integer i = 10;
Integer j = 10;
Integer a = 128;
Integer b = 128;
int k = 10;
int kk = 128;
Integer m = new Integer(10);
Integer n = new Integer(10);
//输出所有identityHashCode
System.out.println(System.identityHashCode(i));
System.out.println(System.identityHashCode(j));
System.out.println(System.identityHashCode(a));
System.out.println(System.identityHashCode(b));
System.out.println(System.identityHashCode(k));
System.out.println(System.identityHashCode(kk));
System.out.println(System.identityHashCode(m));
System.out.println(System.identityHashCode(n));
System.out.println(k == m);

试着分析一下各个对象的hash码：
- i - 654845766：之前说到这个 i 是从IntegerCache里面拿的
- j - 654845766：从IntegerCache里面拿的所以和 i 相等
- a - 1712536284：不在-128~127之内，新建对象
- b - 2080166188：不在-128~127之内，新建对象，新对象和a不同
- k - 654845766：因为identityHashCode()只接受Object不接受基本类型，所以会触发装箱就变成了Integer.valueOf(k)这个10是从IntegerCache里面拿的，所以和i、j相等
- kk - 1123225098：同k，装箱后不在范围内，新建对象，所以和其他不等
- m - 606548741：新建的对象
- n - 1528637575：新建对象
- k == m - true：int和integer比较时integer会触发拆箱所以相等
装箱、拆箱总结：
- int转integer就是装箱Integer.valueOf()，integer转int就是拆箱intValue()
- 字面量声明会优化装箱，装箱执行时范围在-128~127就读缓存！
- PS：Integer为空，null.intValue()触发拆箱时会报空指针异常。这个是技术群里某个同学提出的，不太明白为什么会提出来，不过也顺便记下了。