一文彻底搞懂java中的包装类Integer

由于包装类可以自动装箱和拆箱，并且Integer内置缓存，所以Integer对象间的比较被搞的各位的d疼，但是别急下面让我来慢慢对Integer展开介绍。

装箱与拆箱

Integer是int的包装类，很多时候我们可以把他当做int来使用，这几乎都归结于它的自动装箱和拆箱功能，那么什么是装箱呢？请看下面的一段代码：

public class IntegerDemo1 {
    public static void main(String[] args) {
        Integer a = 3;
    }
}

我们可以看到左边3是常量，而右边Integer是类，3可以直接赋值给左边，其实其底层是把3转化成Integer对象，因此把常量包装成对象我们就称为装箱，那么底层具体是如何转化的呢？我们把上面这段代码翻译成jvm指令如下：

0: iconst_3            // 这里相当于取出常量3供以使用
1: invokestatic  #2    // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; 注意看这里！这里调用了Integer.valueOf()方法
4: astore_1            // 将a对象存放到局部变量表中

从上述字节码可以看书Integer a = 3 实际上就等于 Integer a = Integer.valueOf(3),这个valueOf()方法就是用来把int转成Integer类型的。
介绍完装箱了，拆箱其实就是跟装箱反着来就行了，我们直接看代码：

public class IntegerDemo1 {
    public static void main(String[] args) {
        Integer a = 3; // 装箱
        int b = a; //拆箱 
    }
}

我们可以看到拆箱其实就是包装类型直接赋值给基本类型，其实其底层原理就是把包装类型转换成基本类型，我们依旧来看一下jvm指令：

0: iconst_3
1: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
4: astore_1
// 上面三行是Integer a = 3的字节码
5: aload_1                           // 这边就是把刚刚保存的对象a先拿出来
6: invokevirtual #3                  // Method java/lang/Integer.intValue:()I 注意看这里，这里其实就是调用a.intValue()方法
9: istore_2                          // 将变量b保存在局部变量表中

从以上字节码我们可以看出int b = a其实底层就会把这句代码转化为 int b = a.intValue(),而intValue()就是把a对象对象的值返回。

Integer之缓冲区

所谓缓存区就是，Integer内部有个缓存，里面默认保存了-128-127 的Integer对象，我们如果要用到该范围内的对象，直接从缓冲区拿就可以了，不用多次创建，我们打开Integer源码

public final class Integer extends Number implements Comparable<Integer> {
    // 我们可以看到Integer内部有个一静态内部类IntegerCache，其中保存了一些Integer对象的缓存
    private static class IntegerCache {
        // 范围最低值-128
        static final int low = -128;
        // 最大范围非固定但是有默认值，127，在下面的静态代码块中可以看出
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            // 最大范围，但是该值可以被配置
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            // 如果配置了最大值，则重新设置最大范围这里不是今天的主题，如果if代码块的东西可以不看
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;
            // 这里就开始创建缓存了，然后循环创建-128-127的Integer对象放入缓存
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

}

Integer之比较

Integer之间的比较知识点稍微多，但是不是很难下面我们以出题的方式先从简单的入手。
好且看第一题！

int a = 3;
int b = 3;
System.out.println(a==b);

这题的输出结果显而易见是true，基本类型之间的比较，比较的直接是值。
且看第二题！

int a = 3;
Integer b = 3; // 注意这边换成了Integer了
System.out.println(a==b);

这题的答案可能就会出乎意料hhh，a是基本类型，b是包装类型，他俩竟能直接比较？确实能的，这题的分析我们需要看以上代码对应jvm指令了（只看重点的地方，其他地方看不懂的可以不看）：

0: iconst_3                         // 取出常量3用于赋值给a
1: istore_1                         // 将变量a保存在局部变量表中
2: iconst_3                         // 再次取出常量3，供变量b使用
3: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; 这边是装箱
6: astore_2                         // 保存变量b
7: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream; 这边是取出System.out用于输出，不重要
10: iload_1                          // 取出变量a
11: aload_2                          // 取出对象b
12: invokevirtual #4                  // Method java/lang/Integer.intValue:()I // 注意看这里，这里用b对象调用intValue（）方法，把b对象转换成基本类型进行比较
15: if_icmpne     22                  // 如果两个int类型值不相等，则跳转到22
18: iconst_1
19: goto          23
22: iconst_0
23: invokevirtual #5                  // Method java/io/PrintStream.println:(Z)V
 26: return

上面jvm很长，如果都看不懂，只需要看关键点就好，int和Integer比较会把Integer对象转换成int类型进行比较，因为两个int值都是3，所以答案是true。
且看第三题！

Integer a = 127;
Integer b = 127; 
System.out.println(a==b);

注意a和b都是对象哦，按照我们传统的观念 == 比较对象，其实是比较对象的地址，这边创建了两个对象，所以这边地址理论上是不同的，所以答案应该是false？其实不然，前面我们提到了Integer的对象其内部有缓存区，如果我们取-128-127范围内的对象的话，我们会直接从缓存中取，所以a和b其实是同一个对象，所以比较这两个对象地址是否相等，那自然相同了鸭。
空口无凭，咱们源码见真章！
首先Integer a=127 就等于 Integer a = Integer.valueOf(127)是吧，那我们就来看一下这个valueOf方法。

public static Integer valueOf(int i) {
     // 看一下i是否在缓存内，如果在的话，就直接从缓存中取出一个Integer对象
     if (i >= IntegerCache.low && i <= IntegerCache.high)
         return IntegerCache.cache[i + (-IntegerCache.low)];
     return new Integer(i);
}

到这里第三题应该是讲明白了，哦，对了，我们再来举个例子验证一下，把127改成128：

Integer a = 128;
Integer b = 128;
System.out.println(a==b);

这是答案就是false了，因为128过了缓存的范围了，所以直接创建了两个Integer对象，所以a和b的地址不一样，所以结果为false。
好了Integer就介绍到这里了，Integer的常用方法就不介绍了看看api就好了。有不对的地方欢迎大家指正。