自动装箱和自动拆箱

什么是自动拆装箱

自动装箱：Java自动将原始类型值转换成对应的对象，比如将int的变量转换成Integer对象，这个过程叫做装箱，

自动拆箱：反之将Integer对象转换成int类型值，这个过程叫做拆箱。

简单来说，装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。因为这里的装箱和拆箱是自动进行的非人为转换，所以就称作为自动装箱和拆箱.

//自动装箱
Integer total = 99; 
//自定拆箱
int totalprim = total;

自动拆箱和装箱是从JDK5.0才开始有的，它方便了基本数据类型和其对应的包装类型之间的转换。

 java中有8中基本的数据类型,这八种基本的数据类型都有对应的封装类型,

下面是对应关系:

 

 

进行自动拆装箱的时候，是有一个范围的，一旦超出这个范围，那么指向的就不是同一个对象，而是返回一个新创建的对象了，这个范围在Integer类中的一个内部私有类IntegerCache可以体现出来 。

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

integer源码：

public static Integer valueOf(int i) {
  return  i >= 128 || i < -128 ? new Integer(i) : SMALL_VALUES[i + 128];
 }

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

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

private static final Integer[] SMALL_VALUES = new Integer[256];

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

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);  //true
        System.out.println(i3==i4);  //false
    }
}

i1和i2会进行自动装箱，执行了valueOf函数，它们的值在(-128,128]这个范围内，它们会拿到SMALL_VALUES数组里面的同一个对象SMALL_VALUES[228]，它们引用到了同一个Integer对象，所以它们肯定是相等的。

i3和i4也会进行自动装箱，执行了valueOf函数，它们的值大于128，所以会执行new Integer(200)，也就是说它们会分别创建两个不同的对象，所以它们肯定不等。

 

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); //false
        System.out.println(i3==i4); //false
    }
}

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

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

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

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

 

总结：这些进行自动拆装箱的基本类型的范围如下：

1. boolean类型的值

2.所有的byte的值

3.在-128~127的short类型的值

4.在-128~127的int类型的值

5.在\ u0000~\ u00ff 之间的char类型的值

而其中double和float又有所不同

即 Java对部分经常使用的数据采用缓存技术，即第一次使用该数据则创建该数据对象并对其进行缓存，当再次使用等值对象时直接从缓存中获取，从而提高了程序执行性能。

Java中的==有两种作用：如果是基本数据类型则用于判断其值是否相等；如果为引用类型则用于判断两者的地址是否相同。此处均为引用类型，所以在缓存中的会引用的是同一块地址，所以使用==判断时其结果为true。不在缓存范围的为false。

而下面代码为创建新的对象，不储存在缓存中：

boolean flag = new Integer(100)==new Integer(100);
System.out.println(flag); //false

总体来说，基本类型的包装类类似于String类。

而下面代码：

int x=1000;
Integer y=new Integer(1000);
boolean flag = x==y;
System.out.println(flag); //true

基本数据类型和其封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer y会自动拆箱为int类型再进行比较，显然返回true

java为什么要引入自动装箱和拆箱的功能？

举个例子:主要是用于java集合中，List<Inteter> list=new ArrayList<Integer>();

list集合如果要放整数的话，只能放对象，不能放基本类型，

因此需要将整数自动装箱成对象,基本数据类型。

如int,float,double,boolean,char,byte,不具备对象的特征，不能调用方法。

注意点(弊端):

容易生成无用对象,因为自动装箱会隐式地创建对象，像前面提到的那样，如果在一个循环体中，会创建无用的中间对象，这样会增加GC压力，拉低程序的性能。所以在写循环时一定要注意代码，避免引入不必要的自动装箱操作.