java 基础 int与Integer值比较

    /**
     * 1.基本类型只能按值传递，而每个基本类型对应的封装类是按引用传递的。
     * 2.从性能上说java中的基本类型是在堆栈上创建的，而所有的对象类型都是在堆上创建的，（对象的引用在堆栈上创建）
     * 3.自动装箱和自动拆箱,java对于Integer与int的自动装箱与拆箱的设计，是一种模式：叫享元模式（flyweight）
     * 自动装箱：将基本数据类型重新转化为对象
     * 例：
     * <code>
     * public class Test {
     * public static void main(String[] args) {
     * // 声明一个Integer对象，用到了自动的装箱：解析为:Integer num = Integer.valueOf(9);
     * Integer num = 9;
     * }
     * }
     * </code>
     * 自动拆箱：将对象重新转化为基本数据类型
     * 例：
     * <code>
     * public class Test {
     * public static void main(String[] args) {
     * / /声明一个Integer对象
     * Integer num = 9;
     * <p>
     * // 进行计算时隐含的有自动拆箱
     * System.out.print(num--);
     * }
     * }
     * </code>
     * （1）加大对简单数字的重利用，Java定义在自动装箱时对于在-128~127之内的数值，它们被装箱为Integer对象后，会存在内存中被重用，始终只存在一个对象。
     * （2）而如果在-128~127之外的数，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个 Integer对象。
     */
    @Test
    public void compareValue() {
        // 基本类型变量
        int int1 = 2;
        int int2 = 2;
        int int3 = 127;
        int int4 = 128;
        int int5 = 127;
        int int6 = 128;
        // 引用（包装）类型变量，非new直接赋值的变量
        Integer integer1 = 2;
        Integer integer2 = 2;
        Integer integer3 = 127;
        Integer integer4 = 128;
        Integer integer5 = 127;
        Integer integer6 = 128;
        // 引用（包装）类型变量，new 的对象地址赋值的变量
        Integer integerNew1 = new Integer(2);
        Integer integerNew2 = new Integer(2);
        Integer integerNew3 = new Integer(127);
        Integer integerNew4 = new Integer(128);
        Integer integerNew5 = new Integer(127);
        Integer integerNew6 = new Integer(128);

        // 1.基本类型比较，在堆栈中保存，可直接比较
        System.out.println("int1[" + int1 + "]==int2[" + int2 + "] >> " + (int1 == int2));
        System.out.println("int3[" + int3 + "]==int5[" + int5 + "] >> " + (int3 == int5));
        System.out.println("int4[" + int4 + "]==int6[" + int6 + "] >> " + (int4 == int6));
        /* 2.Integer作为变量时(在非new出来时)对于-128到127之间的数，会进行缓存，当超过范围就是new Integer()来new一个对象
         * 也就是说int integer3 = 127时,在范围之内，这个时候就存放在缓存中，当再创建integer5时，java发现缓存中存在127这个数了，就直接取出来赋值给integer5，
         * 所以integer3 == integer5为true;
         * 当integer4、integer6的值超过范围，java开始通过new Integer()来创建，integer4、integer6都是new Integer(128)出来的变量
         * 所以integer4 == integer6为true;
         */
        System.out.println("integer1[" + integer1 + "]==integer2[" + integer2 + "] >> " + (integer1 == integer2));
        System.out.println("integer3[" + integer3 + "]==integer5[" + integer5 + "] >> " + (integer3 == integer5));
        System.out.println("integer4[" + integer4 + "]==integer6[" + integer6 + "] >> " + (integer4 == integer6));
        /*
         * 3. 通过new出来的对象的变量，创建的对象其引用内存地址不同,所以即使值相等，内存地址也不同，
         * 所以都为false，可以通过equals比较值是否相等
         */
        System.out.println("integerNew1[" + integerNew1 + "]==integerNew2[" + integerNew2 + "] >> " + (integerNew1 == integerNew2));
        System.out.println("integerNew3[" + integerNew3 + "]==integerNew5[" + integerNew5 + "] >> " + (integerNew3 == integerNew5));
        System.out.println("integerNew4[" + integerNew4 + "]==integerNew6[" + integerNew6 + "] >> " + (integerNew4 == integerNew6));
        /*
         * 4.Integer是int的封装类，当Integer与int进行==比较时，Integer就会拆箱成一个int类型，
         * 相当于两个int类型进行比较，这里的Integer,不管是直接赋值，还是new创建的对象引用，
         * 只要跟int比较就会拆箱为int类型，就是相等的，所以都为true。
         */
        System.out.println("int1[" + int1 + "]==integer1[" + integer1 + "] >> " + (int1 == integer1));
        System.out.println("int3[" + int3 + "]==integer3[" + integer3 + "] >> " + (int3 == integer3));
        System.out.println("int4[" + int4 + "]==integer4[" + integer4 + "] >> " + (int4 == integer4));
        System.out.println("int1[" + int1 + "]==integerNew1[" + integerNew1 + "] >> " + (int1 == integerNew1));
        System.out.println("int3[" + int3 + "]==integerNew3[" + integerNew3 + "] >> " + (int3 == integerNew3));
        System.out.println("int4[" + int4 + "]==integerNew4[" + integerNew4 + "] >> " + (int4 == integerNew4));
        /*
         * 5.变量创建方式不一样，integer1、integer3、integer4为直接赋值的变量，而integerNew1、integerNew3、integerNew4为new对象的引用
         * 非new生成的Integer变量指向的是静态常量池中cache数组中存储的数据，指向了堆中的Integer对象，
         * 而new Integer()生成的变量指向堆中新建的对象，两者在内存中的对象引用（地址）不同。
         * 所以任何时候比较时都为false
         */
        System.out.println("integer1[" + integer1 + "]==integerNew1[" + integerNew1 + "] >> " + (integer1 == integerNew1));
        System.out.println("integer3[" + integer3 + "]==integerNew3[" + integerNew3 + "] >> " + (integer3 == integerNew3));
        System.out.println("integer4[" + integer4 + "]==integerNew4[" + integerNew4 + "] >> " + (integer3 == integerNew4));


        /*
         * 总结：
         * 1、任何时候，非new的Integer与new的Integer的变量比较都不会相等。不会经历拆箱过程，因为它们存放的内存地址不一样。
         * 2、两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false。
         * 3、两个都是new出来的,则为false。
         * 4、int和integer(new或非new)比较，都为true，因为会把Integer自动拆箱为int，其实就是相当于两个int类型比较。
         */
    }