Int和Integer的区别

一、Int和Integer的区别

1、Integer是Int的包装类，Int是八种基本数据类型之一。
2、Integer变量必须实例化以后才可以使用，而Int变量不需要实例化。
3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象，而Int是直接存储数据值。
4、Integer的默认值是null，Int的默认值是0。

Int和Integer的比较（扩展）

先来看一段代码：

public class Test {
    public static void main(String[] args) {

        Integer a = new Integer(10);
        Integer b = new Integer(10);
        System.out.println(a == b);

        Integer c = new Integer(10);
        int d = 10;
        System.out.println(c == d);

        Integer e = new Integer(10);
        Integer f = 10;
        System.out.println(e == f);

        Integer g = 10;
        Integer h = 10;
        System.out.println(g == h);

        Integer i = 128;
        Integer j = 128;
        System.out.println(i == j);

        int k = 10;
        Integer l = 10;
        System.out.println(k == l);

        int m = 128;
        Integer n = 128;
        System.out.println(m == n);

    }

}

输出结果为：

思考一下为什么？
第一组：

		//1、false
        Integer a = new Integer(10);
        Integer b = new Integer(10);
        System.out.println(a == b);

a和b是两个Integer变量，Integer变量实际上是对Integer对象的引用，而new生成的是两个对象，内存地址不同，所以a和b不相等，结果为false。

第二组：

		//2、true
        Integer c = new Integer(10);
        int d = 10;
        System.out.println(c == d);

由于包装类Integer和基本数据类型Int在进行比较的时候，Java会自动拆箱为Int（c.intValue(10) == d），然后进行比较，实际上就是两个Int变量的比较，只要两个变量的值是相等的，结果就为true。

第三组：

		//3、false
        Integer e = new Integer(10);
        Integer f = 10;
        System.out.println(e == f);

和第二组不同的是， e 和 f 都是Integer变量，区别是非new生成的Integer变量 f 指向的是Java常量池中的对象，new生成的Integer变量指向堆中新建的对象，两者在内存中地址不同，所以结果为false。

第四组：

		//4、true
        Integer g = 10;
        Integer h = 10;
        System.out.println(g == h);

对于 g == h，两个Integer类的比较应该用equals，而这里使用==判断地址，结果本应该是false，但打印出来却是true，这是为什么？
首先，直接声明Integer g = 10;的时候，Java自动装箱为Integer g = Integer.valueOf(10)，查看Integer类的valueOf方法：

// range [-128, 127] must be interned (JLS7 5.1.7)
// static final int low = -128;
// assert IntegerCache.high >= 127;
public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

观察源码可以发现，当 i>=-128并且 i<=127的时候，第一次声明会将 i 的值放入缓存中，第二次直接复用缓存里边已有的对象，而不是重新创建一个Integer对象。这个区间内的Integer值可以直接使用 == 判断，但这个区间外的所有数据，都会在堆上产生，并不会复用已有对象。
这组的 g 和 h 都在这个区间内，所以结果为true。

第五组：

		//5、false
        Integer i = 128;
        Integer j = 128;
        System.out.println(i == j);

第五组刚好可以和第四组进行对比，因为 i 和 j 不在那个区间内，所以都是在堆上新产生一个对象，结果为false。

第六组：

		//6、true
        int k = 10;
        Integer l = 10;
        System.out.println(k == l);

Integer的自动拆箱功能，k == l.intValue(10)，也就是比较两个基本数据类型，结果当然为true。

第七组：

		//7、true
        int m = 128;
        Integer n = 128;
        System.out.println(m == n);

和第六组一样的道理，总之Int和Integer比较，无论是否有new，结果都为true，因为Java会把Integer自动拆箱为Int再去比较。
再看一段代码：

public class Test {
    public static void main(String[] args) {

        Integer a = 1;
        Integer b = 2;
        Integer c = 3;
        Integer d = 3;

        Integer e = 321;
        Integer f = 321;

        Long g = 3L;
        Long h = 2L;

        System.out.println(c == d);
        System.out.println(e == f);
        System.out.println(c == (a + b));
        System.out.println(c.equals((a+b)));
        System.out.println(g == (a+b));
        System.out.println(g.equals(a+b));
        System.out.println(g.equals(a+h));

    }

}

输出结果为：

• c == d就是第一个示例中的第四组，结果为true。
• e == f就是第一个示例中的第五组，结果为false。
• c == (a + b)，由于 a + b 包含了算术运算，Java会进行自动拆箱，==又将 c 自动拆箱，所以比较的是数值是否相等，结果为true。
• c.equals((a+b))，a 和 b 先各自调用intValue()方法自动拆箱，得到 a + b 的结果后再调用Integer.valueOf()方法自动装箱，再进行equals比较，结果为true。
• g == (a+b)，首先计算a + b，也是先各自调用intValue()方法自动拆箱得到数值，由于 g 是Long类型的，也会自动拆箱为long，==运算符能够将小范围的数据类型转换为大范围的数据类型，也就是把 int 转换为 long，然后把两个long类型的数值进行比较，结果为true。
• g.equals(a+b)，同理a+b会先自动拆箱，然后将结果自动装箱，但是equals 运算符不会进行类型转换，所以是Long.equals(Integer)，结果为false。
• g.equals(a+h)，a + h 自动拆箱后是 int + long，运算符 + 进行类型转换，结果为long，long再自动装箱为Long，两个Long进行equals比较，结果为true。