java知识点 --- 装箱与拆箱

一、什么是装箱？什么是拆箱？

     Java为每种基本数据类型都提供了对应的包装器类型，如下：

     在jdk1.5之前，生成一个数值为10的Integer对象必须写为：Integer i = new Integer(10);但是1.5及其以后的版本都加入了自动装箱的功能，就可以直接写为：Integer i = 10;

    装箱和拆箱的实现过程：装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 xxxValue方法实现的。（xxx代表对应的基本数据类型）。

二、常见面试题

1.下面这段代码的输出结果是什么？

public class Main {
    public static void main(String[] args) {
         
        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;
         
        System.out.println(i1==i2);
        System.out.println(i3==i4);
    }
}

答：true   false

解析：Integer的valueOf()方法的源码如下：

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


private static class IntegerCache {
        static final int high;
        static final Integer cache[];
 
        static {
            final int low = -128;
 
            // high value may be configured by property
            int h = 127;
            if (integerCacheHighPropValue != null) {
                // Use Long.decode here to avoid invoking methods that
                // require Integer's autoboxing cache to be initialized
                int i = Long.decode(integerCacheHighPropValue).intValue();
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - -low);
            }
            high = h;
 
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }
 
        private IntegerCache() {}
    }

     在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。

2.下面这段代码的输出结果是什么？

public class Main {
    public static void main(String[] args) {
         
        Double i1 = 100.0;
        Double i2 = 100.0;
        Double i3 = 200.0;
        Double i4 = 200.0;
         
        System.out.println(i1==i2);
        System.out.println(i3==i4);
    }
}

答：false  false

解析：为什么Double类的valueOf方法会采用与Integer类的valueOf方法不同的实现。很简单：在某个范围内的整型数值的个数是有限的，而浮点数却不是。

　　注意，Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。

　　　　　Double、Float的valueOf方法的实现是类似的。

3.下面这段代码输出结果是什么：

public class Main {
    public static void main(String[] args) {
         
        Boolean i1 = false;
        Boolean i2 = false;
        Boolean i3 = true;
        Boolean i4 = true;
         
        System.out.println(i1==i2);
        System.out.println(i3==i4);
    }
}

答：true  true

解析：

public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }


 public static final Boolean TRUE = new Boolean(true);
 
 public static final Boolean FALSE = new Boolean(false);

4.下面程序的输出结果是什么？

public class Main {
    public static void main(String[] args) {
         
        Integer a = 1;
        Integer b = 2;
        Integer c = 3;
        Integer d = 3;
        Integer e = 321;
        Integer f = 321;
        Long g = 3L;
        Long h = 2L;
         
        System.out.println(c==d);
        System.out.println(e==f);
        System.out.println(c==(a+b));
        System.out.println(c.equals(a+b));
        System.out.println(g==(a+b));
        System.out.println(g.equals(a+b));
        System.out.println(g.equals(a+h));
    }
}

答：true  false  true  true true false true

解析：

c==(a+b)  =》a+b包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法），因此它们比较的是数值是否相等。

c.equals(a+b)  =》会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，便调用Integer.valueOf方法，再进行equals比较。调用的是Integer.java中的equals方法，源码如下：

public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

在进行算术运行时，如果两个数字均为int类型的，装箱过程调用的是Integer.valueOf；只要存在一个long类型的，装箱调用的Long.valueOf方法。

g.equals(a+b)  =》 a+b -> int ->装箱后为Integer ,调用的是Long.java中的equals方法，源码如下：

 public boolean equals(Object obj) {
        if (obj instanceof Long) {
            return value == ((Long)obj).longValue();
        }
        return false;
    }

针对本题中，a+b装箱后为Integer,所以最终执行结果为false。

g.equals(a+h) =》a+h -> long ->装箱后为Long ,调用的是Long.java中的equals方法，执行结果为true。