Java 装箱 拆箱

以前都没有听说过，这次看海子的博客，真是长见识了！

https://www.cnblogs.com/dolphin0520/p/3780005.html

简单一点说，装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。

        //自动装箱
        Integer num = 3;
        //自动拆箱
        int count = num;

在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。

因此可以用一句话总结装箱和拆箱的实现过程：

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

下面这段代码是Integer的valueOf方法的具体实现：

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

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

IntegerCache.cache[]是一个静态的Integer数组对象，也就是说最终valueOf返回的都是一个Integer对象。

上面我们看到在Integer的构造函数中，它分两种情况： 

1、i >= 128 || i < -128 =====> new Integer(i) 
2、i < 128 && i >= -128 =====> SMALL_VALUES[i + 128]

1 static final Integer cache[] = new Integer[256];

cache本来已经被创建好，也就是说在i >= 128 || i < -128是会创建不同的对象，在i < 128 && i >= -128会根据i的值返回已经创建好的指定的对象。

下面是几个例子：

package lesson1213;

public class TestZhuangXiang {

    public static void main(String[] args) {
        //自动装箱
        Integer num1 = 3;        
        Integer num2 = 3;
        
        Integer num3 = 200;
        Integer num4 = 200;
        
        System.out.println(num1==num2);  //true
        System.out.println(num3==num4);  //false
        
    }

}

如果是Double类呢？

        Double d1 = 1.0;
        Double d2 = 1.0;
        Double d3 = 200.0;
        Double d4 = 200.0;
        
        System.out.println(d1==d2);  //false
        System.out.println(d3==d4);  //false

看看上面的执行结果，跟Integer不一样，这样也不必奇怪，因为它们的valueOf实现不一样，结果肯定不一样，那为什么它们不统一一下呢？ 
这个很好理解，因为对于Integer，在(-128,128]之间只有固定的256个值，所以为了避免多次创建对象，我们事先就创建好一个大小为256的Integer数组SMALL_VALUES，所以如果值在这个范围内，就可以直接返回我们事先创建好的对象就可以了。

但是对于Double类型来说，我们就不能这样做，因为它在这个范围内个数是无限的。 
总结一句就是：在某个范围内的整型数值的个数是有限的，而浮点数却不是。

所以在Double里面的做法很直接，就是直接创建一个对象，所以每次创建的对象都不一样。

    public static Double valueOf(double d) {
        return new Double(d);
    }

下面我们进行一个归类： 
Integer派别：Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。 
Double派别：Double、Float的valueOf方法的实现是类似的。每次都返回不同的对象。

下面对Integer派别进行一个总结，如下图： 

下面我们来看看另外一种情况：Boolean类

        Boolean b1 = true;
        Boolean b2 = true;
        Boolean b3 = false;
        Boolean b4 = false;
        System.out.println(b1==b2); //true
        System.out.println(b3==b4); //true

可以看到返回的都是true，也就是它们执行valueOf返回的都是相同的对象。

    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);

下面讲述下equal  和 == 在这几个类中的应用

package lesson1213;

public class Test {
    
    /*1:== 比较两个值是否相等。如果作用于基本数据类型，比较其值是否相等。
         * 如果作用于引用类型变量，则比较的是所指向对象的地址。
      2:在object中equal,equal方法是用来比较两个对象的引用是否相等，即是否指向同一个对象。
      但是有一些类例如String,Double, Date,Interger等，都对equal方法进行了重写用来比较应用的对象所存储的值是否相等。
      注意equal不能用于基本数据类型。
    */    
    
    public static void main(String[] args) {
        Integer num1 = 200;
        int num2 = 200;
        System.out.println(num1==num2);         //true
        System.out.println(num2==num1);            //true    
        System.out.println(num1.equals(num2));  //true
        
        Integer a = 1;
        Integer b = 2;
        Integer c = 3;
        Integer d = 3;
        Integer e = 300;
        Integer f = 300;
        Long g = 3L;
        Long h = 2L;
        
        Integer e1 = 100;
        Integer e2 = 200;
        int e3=100;
        int e4=200;
        
        System.out.println(c==d);              //true,  没有疑问
        System.out.println(e==f);              //false, 超过范围-128~127，每次都重新new
        System.out.println(e==f+0);            //true, 如果有操作运算符，就是比较的值
        System.out.println(c==(a+b));          //true
        System.out.println(c.equals((a+b)));   //true
        System.out.println(g==(a+b));          //true   //有操作运算符
        System.out.println(g.equals((a+b)));   //false  //类型不一样
        System.out.println(g.equals((a+h)));   //true   //自动提升类型
        System.out.println(g==(a+h));          //true    
        System.out.println(e==(e1+e2));        //true
        System.out.println(e.equals((e1+e2))); //true
        System.out.println(e==(e1+e4));        //true
        System.out.println(e.equals((e2+e3))); //true
    }
}

总结：

1：当 "=="运算符的两个操作数都是 包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动  拆箱的过程）。

补充："=="只有两个都是包装类型，并且没有操作运算，才是比较是否指向同一个对象。如果有一个是包装类型，另一个不是包装类型，则比较的就是值。

          当两种不同类型用==比较时，包装器类的需要拆箱， 当同种类型用==比较时，会自动拆箱或者装箱

          当一个基础数据类型与封装类进行==、+、-、*、/运算时，会将封装类进行拆箱，对基础数据类型进行运算。

2：equal, 首先判断类型是否一样，如果一样，就看值是否相等。对于包装器类型，equals方法并不会进行类型转换。

下面是Integer中对equal进行重载：

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

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

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

下面这个例子有点奇怪，自己也不是很了解，但是程序运行结果就是这样：会自动提升类型，所以相等

        int e5 = 3;
        long e6 = 3;        
        //Long e66 = 3;                        //编译失败Type mismatch: cannot convert from int to Long
        Long e666=3L; 
        Double e7 = 3.0;
        Integer e8 = 3;
        
        System.out.println(e5==e6);            //true
        System.out.println(e5==e666);          //true
        System.out.println(e5==e7);            //true
        System.out.println(e6==e7);            //true, 一边是基础类型，一般是包装类，比较值
        System.out.println(e6==e8);            //true
        //System.out.println(e7==e8);          //编译失败Incompatible operand types Double and Integer

到此处，应该对包装类和装箱，拆箱比较了解了，在遇见这样的题目应该没有问题了。