（1）Integer缓存池

在 JDK8 中，Integer 缓存池可缓存的数值范围为-128 到 127。

（2）Integer.valueOf(xxx)的valueOf分析

1. 参数为int

在申请一个 [-128,127] 内的数时，其实是从 cache 中直接取出来用的，

如果不在这个范围则是 new 了一个 Integer 对象

 

2.参数为String

关于parseInt方法：

static int parseInt(String s)   //默认转化为10进制整型

static int parseInt(String s, int radix)    //转化为radix进制整型

（3）Integer创建的两种方式

Integer a = new Integer(1);
        Integer b = new Integer(1);
        System.out.println(a==b);   //false     创建对象的方式 两个不同的内存地址


        Integer a1 = new Integer(128);
        Integer b1 = new Integer(128);
        System.out.println(a1==b1);   //false   创建对象的方式 两个不同的内存地址


        Integer c = Integer.valueOf(123);
        Integer d = Integer.valueOf(123);
        System.out.println(c==d);    //true     从常量池中取的

        Integer c1 = Integer.valueOf(128);
        Integer d1 = Integer.valueOf(128);
        System.out.println(c1==d1);  //false    超过了127  则新实例化了一个Integer类型的对象   自动装箱

（4）Integer 的拆箱和装箱

Integer i3 = 1;// 当把一个int型赋给一个Integer型时，引发编译器自动装箱，转化为Integer i3 = new Integer(1);

i4 = new Integer(1);// 由于基本类型无法指定对象，所以编译器会自动拆箱，该条语句会转换为：int i4  = new Integer(1).intvalue();

 （5）隐式/显示类型转换

 高转低    --------   显示转换

 低转高     --------   隐式转换

（6）综合及总结

int int1 = 12;
        int int2 = 12;
        Integer integer1 = new Integer(12);
        Integer integer2 = new Integer(12);
        Integer integer3 = new Integer(127);
        Integer a1 = 127;
        Integer a2 = 127;
        Integer a = 128;
        Integer b = 128;
        System.out.println("int1 == int2 -> " + (int1 == int2));    // true      整型比较
        System.out.println("int1 == integer1 -> " + (int1 == integer1));    // true     int与Integer比较
                                                                            // Integer自动拆箱   等价于第一组

        System.out.println("integer1 == integer2 -> " + (integer1 == integer2));        // false    两个对象   不会拆箱
                                                                                        //不同的内存地址

        System.out.println("integer3 == a1 -> " + (integer3 == a1));  // false          //等价于上一组
        System.out.println("a1 == a2 -> " + (a1 == a2));       // true     从常量池中直接取引用
        System.out.println("a == b -> " + (a == b));        // false       超过了127   需要new