Integer s=new Integer(9); Integer t=new Integer(9); Long u=new Long(9);
Integer和Integer比较的时候,由于直接赋值的话会进行自动的装箱。所以当值在[-128,127]中的时候,由于值缓存在IntegerCache中,那么当赋值在这个区间的时候,不会创建新的Integer对象,而是直接从缓存中获取已经创建好的Integer对象。而当大于这个区间的时候,会直接new Integer。
当Integer和Integer进行==比较的时候,在[-128,127]区间的时候,为true。不在这个区间,则为false
当Integer和Integer进行equals比较的时候,由于Integer的equals方法进行了重写,比较的是内容,所以为true
Integer和new Integer : new Integer会创建对象,存储在堆中。而Integer在[-128,127]中,从缓存中取,否则会new Integer.
所以 Integer和new Integer 进行==比较的话,肯定为false ; Integer和new Integer 进行equals比较的话,肯定为true
new Integer和new Integer进行==比较的时候,肯定为false ; 进行equals比较的时候,肯定为true
原因是new的时候,会在堆中创建对象,分配的地址不同,==比较的是内存地址,所以肯定不同
装箱过程是通过调用包装器的valueOf方法实现的
拆箱过程是通过调用包装器的xxxValue方法实现的(xxx表示对应的基本数据类型)
总结:Byte、Short、Integer、Long这几个类的valueOf方法实现类似的。所以在[-128,127]区间内,==比较的时候,值总是相等的(指向的是同一对象),在这个区间外是不等的。
而Float和Double则不相等, Boolean的值总是相等的
(1)Integer i=9; (2)Integer j=Integer.valueOf(9);
Integer s = 9;
Integer t = 9;
则s == t是truenew Integer(int)
是已经废弃了方法。 /**
* Compares this object to the specified object. The result is
* {@code true} if and only if the argument is not
* {@code null} and is an {@code Integer} object that
* contains the same {@code int} value as this object.
*
* @param obj the object to compare with.
* @return {@code true} if the objects are the same;
* {@code false} otherwise.
*/
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}
不是同一类型就是falseInteger a = 1000, b = 1000; System.out.println(a == b);//1 false Integer c = 100, d = 100; System.out.println(c == d);//2 true
Integer a = new Integer(1000); Integer b = new Integer(1000); System.out.println(a == b);//1 false Integer c = new Integer(100); Integer d = new Integer(100); System.out.println(c == d);//2 false
int i=0; Integer j = new Integer(0); System.out.println(i=j);//true System.out.println(j.equals(i));//true System.out.println(i.equals(j));//编译错误,因为基本数据类型i没有equals()方法基本型和基本型包装类进行“==”运算符的比较,基本型包装类将会自动拆箱变为基本型后再进行比较,因此Integer(0)会自动拆箱为int类型再进行比较,显然返回true;
public class IntegerTest { public static void main(String args[]){ Integer s1=new Integer(9); //直接创建对象 Integer t1=new Integer(9); //直接创建对象 Integer s2=new Integer(128); //直接创建对象 Integer t2=new Integer(128); //直接创建对象 Integer a1 = 9; //自动装箱 Integer b1 = 9; //自动装箱 Integer a2 = 128; //自动装箱 Integer b2 = 128; //自动装箱 System.out.println(s1 == t1); //false,两个不同的实例对象 System.out.println(s1.equals(t1)); //true System.out.println(s2 == t2); //false,两个不同的实例对象 System.out.println(s2.equals(t2)); //true System.out.println(a1 == b1); //true,支持自动装箱且值位于-128到127之间,都指向IntegerCache缓存中的同一个Integer对象 System.out.println(a1.equals(b1)); //true System.out.println(a2 == b2); //false,支持自动装箱但值不在-128到127之间支持自动装箱,不能引用IntegerCache缓存中的同一个Integer对象,需要额外创建两个Integer对象 System.out.println(a2.equals(b2)); //true } }
A.因为s是Integer类型,u是Long类型,不同类型不能用“==”比较,为false
B.s,t因为new了Integer,所以他们指向不同对象的堆,“==”比较地址(非基本类型),为false
C、D、E. Integer重写了equals方法,比较的是值,为true
(s==u) ,因为, s 是 Integer 类型, u 是 Long 类型,两个不同类型的引用不能进行 == 比较。
(s==t) , s 是指向一个 9 的引用,而 t 也是一个指向 9 的引用,虽然都是指向 9 ,但却是指向不同的 9 ,即是两个不同的引用。因此 == 比较返回的是假。
(s.equals(t)) , Integer 的 equals 方法如下:
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false ;
}
是 Integer 的实例且 value 值也相等的情况下返回真,其他返回假。
在这里, s 和 t 都是 Integer 类型且值都为 9 ,因此结果为真。
(s.equals(9)) , 在进行 equals 比较之前,会对 9 调用 Integer.valueOf 方法,进行自动装箱 , 由于 IntegerCache 中已经存在 9 ,所以,直接返回其引用,引用相同, equals 就自然相同了。所以结果为真。
(s.equals( new Integer(9)) ,直接创建了一个新的 Integer 实例,但且值也为 9 ,所以,满足条件,返回真。