笔试题引发的思考--装箱与拆箱

例子1

引用：

http://www.nowcoder.com/questionTerminal/bc5da9d0b8444006a776b7cbfba5d250

public class Main {
public static void main(String[] args) {
Integer i01 = 59;
int i02 = 59;
Integer i03 =Integer.valueOf(59);
Integer i04 = new Integer(59);
System.out.println(i01== i02);
System.out.println(i01== i03);
System.out.println(i03== i04);
System.out.println(i02== i04);
}
}

输出结果：

true

true

false

true

Integer i01=59的时候，会调用Integer的valueOf方法，

public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}

这个方法就是返回一个Integer对象，只是在返回之前，看作了一个判断，判断当前i的值是否在[-128,127]区别，且IntegerCache中是否存在此对象，如果存在，则直接返回引用，否则，创建一个新的对象。

在这里的话，因为程序初次运行，没有59，所以，直接创建了一个新的对象。

int i02=59，这是一个基本类型，存储在栈中。

Integer i03 =Integer.valueOf(59);因为IntegerCache中已经存在此对象，所以，直接返回引用。

Integer i04 = new Integer(59)；直接创建一个新的对象。

System.out.println(i01== i02); i01是Integer对象，i02是int，这里比较的不是地址，而是值。Integer会自动拆箱成int，然后进行值的比较。所以，为真。

System.out.println(i01== i03);因为i03返回的是i01的引用，所以，为真。

System.out.println(i03==i04);因为i04是重新创建的对象，所以i03,i04是指向不同的对象，因此比较结果为假。

System.out.println(i02== i04);因为i02是基本类型，所以此时i04会自动拆箱，进行值比较，所以，结果为真。

例子2

引用：

http://www.nowcoder.com/questionTerminal/ccaf97ecf8f64e73a8982a6e8c792d4e

Integer s=new Integer(9);
Integer t=new Integer(9);
Long u=new Long(9);

Which test would return true?

(s==u)
(s==t)
(s.equals(t))
(s.equals(9))
(s.equals(new Integer(9))

输出结果为：

编译出错

false

true

true

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，所以，满足条件，返回真。

例子3

引用：

http://www.nowcoder.com/questionTerminal/643b145a860f457d8a150869e1a17eba

再来一个例子。

下列 java 程序输出结果为__。

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

输出结果：

true

true

i==j，这个是基本类型与Integer的比较，j会自动拆箱成int类型，然后比较的是值。因此返回真。

j.equals(i)，调用equals方法后，这个i会自动装箱成Integer类型，然后再比较值，所以也返回真。

例子4

引用：

http://www.nowcoder.com/questionTerminal/8b1bd881a81744d79daceaa8244cbf3a

Integer i = 42;
Long l = 42l;
Double d = 42.0;

下面为true的是

A. (i == l)

B. (i == d)

C. (l == d)

D. i.equals(d)

E. d.equals(l)

F. i.equals(l)

G. l.equals(42L)

ABC3个选项很明显，不同类型引用的==比较，会出现编译错误，不能比较。

DEF调用equals方法，因为此方法先是比较类型，而i，d，l是不同的类型，所以返回假。

选项G，会自动装箱，将42L装箱成Long类型，所以调用equals方法时，类型相同，且值也相同，因此返回真。

基本类型间的比较

下面看一个基本类型之间比较的例子

public class Main {
public static void main(String[] args) {
float f=42.0f;
float f1[]=new float[2];
float f2[]=new float[2];
float[] f3=f1;
long x=42;
f1[0]=42.0f;
System.out.println(f1==f2);//false
System.out.println(x==f1[0]);//true
System.out.println(f1==f3);//true
//System.out.println(f2==f1[1]);//Incompatible operand types float[] and float
}
}

原则：基本类型的==比较是比较值的大小。