转载自：

请移步原文

public class Number {
    public static void main(String[] args) {
        
        Integer i1 = 128;  // 对数值128装箱，相当于 Integer.valueOf(128);
        int t = i1; //把对象 i1 拆箱，相当于 i1.intValue() 
        System.out.println(t);
        

        /**
        对于–128到127（默认是127）之间的值,被装箱后，会被放在内存里进行重用
        但是如果超出了这个值,系统会重新new 一个对象
        */
        Integer i1 = 200;
        Integer i2 = 200;

        /**
        注意 == 与 equals的区别
        == 它比较的是对象的地址
        equals 比较的是对象的内容
        */
        if(i1==i2) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }
    }
}

1. int 和Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较。

2. Integer与Integer比较的时候，由于直接赋值的时候会进行自动的装箱，那么这里就需要注意两个问题，一个是-128<= x<=127的整数，将会直接缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是从缓存中获取已经创建好的Integer对象。二：当大于这个范围的时候，直接new Integer来创建Integer对象。

3. new Integer(1) 和Integer a = 1不同，前者会创建对象，存储在堆中，而后者因为在-128到127的范围内，不会创建新的对象，而是从IntegerCache中获取的。那么Integer a = 128, 大于该范围的话才会直接通过new Integer（128）创建对象，进行装箱。

public class Test {
 
	public static void main(String[] args) {
		
		Integer i = new Integer(128);
		Integer i2 = 128;
		
		System.out.println(i == i2);
		
		Integer i3 = new Integer(127);
		Integer i4 = 127;
		System.out.println(i3 == i4);
		
		Integer i5 = 128;
		Integer i6 = 128;
		System.out.println(i5 == i6);
		
		Integer i7 = 127;
		Integer i8 = 127;
		System.out.println(i7 == i8);
	}
}

输出的结果为

false
false
false
true

我们一个一个的进行分析。
第一个情况：

Integer i = new Integer(128);
Integer i2 = 128;

i 是创建的一个Integer的对象，取值是128。
i2 是进行自动装箱的实例，因为这里超出了-128--127的范围，所以是创建了新的Integer对象。
那么i和i2都是Integer的对象咯。存储在堆中，分配的地址不同，在使用==进行判读的时候，由于双方都是对象，所以比较对象的地址是不是相同，这里的地址是不同的，因为new的时候会在堆中重新分配存储空间。

第二个情况：

Integer i3 = new Integer(127);
Integer i4 = 127;
i3 是创建的一个Integer的对象，取值是127.
i4 是进行自动装箱后生成的Integer的对象，其值-128<= i4 <= 127，所以在这里会与第一种情况有所不同，这个i4对象直接取缓存IntegerCache中的对应的对象，当然了也是对象。

那么i3和i4也都是对象咯，而且一个是缓存中的，一个自己new的，既然是对象那么==会比较其地址，因为都new出来的对象（一个是自己new出来的，一个是IntegerCache中new出来的对象），那么自然这两种情况下，在堆中分配的地址是不同的。

第三种情况：

Integer i5 = 128;
Integer i6 = 128;

i5是自动装箱产生的Integer的对象，但是其大小超过了范围：-128<=A <=127，那么，这里会直接自己创建该对象即：new Integer(128);

i6和i5类似的原理。

显然这两个对象都是new出来，在堆中的地址值是不同的，那么==的时候判读其地址是不是相等，也就不一样了。

第四种情况：

Integer i7 = 127;
Integer i8 = 127;
i7、i8是自动装箱产生的对象，其值都是127，那么这里很特殊的是127正好在-128<=i7<=127这个范围内的，那么会去IntegerCache中取，既然都是去IntegerCache中去取，那么自然该对象应该是一个对象，那么再堆中的地址应该是一样的，所以在判读两个对象是不是== 的时候，会输出true

源码解析

下面看下，Integer中的装箱的代码

（转载）Java的Integer和int有什么区别

当不用new Integer的时候，构造方法会通过这个方法来构造对象并返回。那么你看if中的代码就知道了，i>=IntegerCache.low&&i<=IntegerCache.high的时候，从IntegerCache中获取的实例，否则，直接new Integer(i);

下面就是IntegerCache的代码，其中low就是-128,high是默认的127,不过可以进行设置。

通过静态代码块直接创建了256个Integer的对象，从-128到127之间。

所以在第四种情况中，取出来的时候，都是经过了上面的return IntegerCache.cache[i + (-IntegerCache.low)]得到的最终的对象，因为在IntegerCache中是创建好的，不会从新new了，所以地址值是一样的，也就是同一个对象，所以为true。
（转载）Java的Integer和int有什么区别

Java是面向对象的编程语言，一切都是对象，但是为了编程的方便还是引入了基本数据类型，为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换，对应如下：

原始类型：boolean，char，byte，short，int，long，float，double

包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

顺便一提，Java中的基本数据类型只有以上8个，除了基本类型（primitive type），剩下的都是引用类型（reference type）。

所以最基本的一点区别是：Ingeter是int的包装类，int的初值为0，Ingeter的初值为null。除此之外还有区别，请看代码：

public class TestInteger {
    public static void main(String[] args) {
        int i = 128;
        Integer i2 = 128;
        Integer i3 = new Integer(128);
        System.out.println(i == i2); //Integer会自动拆箱为int，所以为true
        System.out.println(i == i3); //true，理由同上
        Integer i4 = 127;//编译时被翻译成：Integer i4 = Integer.valueOf(127);
        Integer i5 = 127;
        System.out.println(i4 == i5);//true
        Integer i6 = 128;
        Integer i7 = 128;
        System.out.println(i6 == i7);//false
        Integer i8 = new Integer(127);
        System.out.println(i5 == i8); //false
        Integer i9 = new Integer(128);
        Integer i10 = new Integer(123);
        System.out.println(i9 == i10);  //false
    }
}

为什么i4和i5比是true，而i6和i7比是false呢？关键就是看valueOf()函数了，这个函数对于-128到127之间的数，会进行缓存， Integer i4 = 127时，会将127进行缓存，下次再写Integer i5 = 127时，就会直接从缓存中取，就不会new了。所以i4和i5比是true，而i6和i7比是false。

而对于后边的i5和i8，以及i9和i10，因为对象不一样，所以为false。

以上的情况总结如下：

1，无论如何，Integer与new Integer不会相等。不会经历拆箱过程，new出来的对象存放在堆，而非new的Integer常量则在常量池（在方法区），他们的内存地址不一样，所以为false。

2，两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false。因为java在编译Integer i2 = 128的时候,被翻译成：Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存。

3，两个都是new出来的,都为false。还是内存地址不一样。

4，int和Integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比。

（转载）Java的Integer和int有什么区别

源码解析

相关推荐