转载自:
https://blog.csdn.net/wangyang1354/article/details/52623703
https://blog.csdn.net/login_sonata/article/details/71001851
http://www.runoob.com/java/java-number.html
请移步原文
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中的装箱的代码
当不用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是面向对象的编程语言,一切都是对象,但是为了编程的方便还是引入了基本数据类型,为了能够将这些基本数据类型当成对象操作,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再去比。