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

例子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
    }
}

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