java中的自动拆装箱

一：是什么

　　java的自动拆装箱，是从jdk1.5之后被引入的，java中的类型分为基本类型和引用类型，而自动拆装箱，可以让基本类型和对应的包装类，无缝转换。先拿最基本的来看。

public class UntoBoxing {

    public static void main(String[] args) {

        int i = new Integer(1);
        Integer i2 = 10;

    }
}

二：为什么

　　先说结论：自动拆装箱是编译器的功劳，相当于一个语法糖，在编译成class字节码文件期间，编译器解语法糖，变成正常的字节码。

public class UntoBoxing
{

	public UntoBoxing()
	{
	}

	public static void main(String args[])
	{
		int i = (new Integer(1)).intValue();
		Integer i2 = Integer.valueOf(10);
	}
}

　　上图是我们通过反编译工具反编译来的代码，

　　1.当我们给基本类型赋值对应的包装类时，会自动调用包装类的intValue()方法，返回一个基本类型的值。

　　2.当我们给引用类型赋值基本类型时，会调用Integer的静态方法valueOf()，返回一个引用类型的对象。

三:什么时候会发生

　　1.赋值

　　　如上，在给基本类型和对应的包装类相互赋值的时候，编译器就自动进行了自动拆装箱操作。

　　2.方法调用传入参数的时候

　　这个的原理基本同上，在调用方法，入栈时，发生拆装箱操作。

　　3.被操作符操作的时候

Integer integer = new Integer(1);
int i = integer + 1;

　　

四：需要注意的问题

　　1.比较值的问题

　　　int和integer类型，互相比较值时，jdk内的Integer类也会有相应的操作。

　　　

int i1 = 3;
Integer i2 = 3;　　　　//编译器解语法糖，变为Integer.valueOf(3);
Integer i3 = 3;　　　　//编译器解语法糖，变为Integer.valueOf(3);

System.out.println(i1 == i2);  //输出true，编译器会解语法糖，表达式变为 i1 == i2.intValue();结果为true
System.out.println(i2 == i3);  //输出true

上图唯一需要注意的一点，就是i2 == i3，为什么会输出true？两个引用类型，使用==比较，不是应该比较地址值的么，那这个输出结果，表明这两个引用了同一个堆中的Integer对象？

答案就在Integer类中，我们查看Integer类的valueOf()方法

  public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)　　　　//从cache里查找传入的i是否在缓存的范围内，如果在缓存内，那么直接从cache中返回，否则新建。
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

上图是integer的valueof方法体，原来，在IntegerCache(Integer里面的静态内部类)的low(-128)和high(默认127，可以通过java.lang.Integer.IntegerCache.high定义)之间的值，就会从IntegerCache里面取，相当于一个缓存了128到127的所有integer的数组，那么当调用Integer.valueOf()方法时，会从这里面查找，这样就能解释了为什么==也会是true，因为他们本身就是从IntegerCache里面的同一个Integer对象。

2.性能问题

　我们看一个例子

      Integer i  = 1 ;

        for (int j = 0; j < 10000; j++) {
            i+=1;

        }

上面代码，表面上看去没什么问题，一个正常的+1操作，循环1w次，那么我们反编译后，看看编译器是怎么处理这个的。

        Integer i = Integer.valueOf(1);
        for (int j = 0; j < 10000; j++)
            i = Integer.valueOf(i.intValue() + 1);

我们来看一下怎么变成上面的这个样子的.

　　a:i+=1;

　　b:i = i + 1;　　由于i是引用类型，i+1会变成 i.intValue() + 1;

　　c:i = i + 1; 　　将一个基本类型的int值传递给一个Integer引用类型，编译器解语法糖，转换为Integer.valueOf(),参数为i.intValue()+1;

　分析可得，Integer类型的++操作，会频繁创建Integer类型的对象！！！堆中的新生代会有大量的无用对象，会加快miniorGC，我们看下图,我们在运行之后，显示的执行System.gc()方法，可以看到回收了大量的内存，这些内存就是我们在循环中自己创建的，如果在一些比较注重性能的系统中，这样的操作造成的后果也是相对严重的。

3.重载问题

　　之前我们说过，在方法中的参数，会自动拆装箱，但是如果有两个方法，会重载，如下图所示，那么会调用哪一个呢？

可以看出，方法重载中，当调用方面对Object和int时，是不会自动拆装箱的，或者Object的优先级比自动拆装箱高。

4.空指针问题

　　基本类型，即使我们不初始化赋值，编译器也会有默认值（int类型赋值为0，boolean类型赋值为false），但是如果是包装类型，是不会有默认值的，所以直接调用，会有空指针异常。

　　这一点也经常被我们用来判断一个值到底是没有初始化，还是就是0。比如客户的年龄，到底是0岁，还是没有输入客户年龄，使用int类型就不能判断出来，但是使用Integer类型就可以区别开来。

总结

　　基本类型和引用类型各有利弊，当我们使用基本类型的时候，对象会有默认值，对象也被存储在栈中(方法内使用)，调用/释放更快，节省了资源，但是并不符合java的面向对象的思想；

　　引用类型更符合java面向对象的思想，可以为空，但是牺牲了性能，所以在实际使用中，要根据具体情况判断。