自动装箱拆箱详解

包装类主要是为了解决，容器类存放基本类型的问题，比如向ArrayList容器中添加原生数据类型的值时，系统会自动的将原生数据类型转化为包装类型对象添加到ArrayList中去，（ArrayList中存放的都是对象）而每次如果手动装箱拆箱，显得太繁琐，所以提供了自动拆装箱的语法糖。

自动装箱拆箱问题：Java**自动**将原生数据类型转换成对应的对象，比如将int的变量转换成Integer对象，这个过程叫做装箱，反之将Integer对象转换成int类型值，这个过程叫做拆箱

自动装箱和自动拆箱如何实现：

  Integer C=new Integer(30);  //定义一个包装类型
        int xx=10;
        int yy=20;
//       将原生int 型手动装箱 转化为包装型（对象）integer
        Integer A = new Integer(xx);
        Integer B = new Integer(yy);
//        将原生int 型自动装箱 转化为包装型（对象）integer
        Integer AA = xx;  // 其实是java在其内部 自动实现了装箱过程， Integer AA = Integer.valueof(xx);
        Integer BB =yy;
        // 将包装型手动拆箱转化为int 型
        int xxx= A.intValue();
        int yyy=B.intValue();
        // 将包装型自动拆箱转化为int 型
         xxx=AA;
         yyy=BB;
//        Integer.parseInt(String str) 是将字符串型转化为int类型   
        System.out.println(xxx);  //10
        System.out.println(yyy);   //20 

自动装箱和拆箱在Java中很常见，比如我们有一个方法，接受一个对象类型的参数，如果我们传递一个原始类型值，那么Java会自动讲这个原始类型值转换成与之对应的对象。最经典的一个场景就是当我们向ArrayList这样的容器中增加原始类型数据时或者是创建一个参数化的类，比如下面的ThreadLocal。

ArrayList<Integer> intList = new ArrayList<Integer>();
intList.add(1); //autoboxing - primitive to object
intList.add(2); //autoboxing

ThreadLocal<Integer> intLocal = new ThreadLocal<Integer>();
intLocal.set(4); //autoboxing

int number = intList.get(0); // unboxing
int local = intLocal.get(); // unboxing in Java

自动装箱拆箱需要注意的几点：
第一点：

        Integer integer1=100;
        Integer integer2=100;
        Integer integer3=300;
        Integer integer4=300;
        System.out.println(integer1==integer2); // true
        System.out.println(integer3==integer4); // false

为什么会出现不一样的结果呢？这是因为
java中基本类型的包装类的大部分都实现了字符串常量池技术，这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类Float，Double 则没有实现。另外 Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池，也即对象不负责创建和管理大于127的这些类的对象。 Integer的常量池 IntegerCache 里允许的范围时-128— 127， 超出范围的，系统会自动通过new关键字来创建对象。
如果是使用new 关键字创建的，也不在常量池里。

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

第二点：

Integer integer100=null;
int int100=integer100;

会抛出异常，在第二行时，会对integer100进行拆箱，也就是对一个null对象执行intValue()方法，当然会抛出空指针异常。所以，有拆箱操作时一定要特别注意封装类对象是否为null。

第三点

        int int400=400;  
        Integer integer400=400;  
        System.out.println(integer400==int400);  // true 
//      为什么会是true ？ 因为当一个原生数据类型和其包装类型进行==比较时，会将包装类型拆箱, 注意的是当进行+，-，*，/基本运算的时候都会进行自动拆箱
        System.out.println(integer400.equals(int400)); // true
//     当一个原生数据类型和其包装类型通过equals方法比较时，会自动装箱，然后比较的是内容的大小

  Integer a = 1;  
        Integer aa = new Integer(1);
        Integer b = 2;  
        Integer c = 3;  
        Integer d = 3;  
        Integer e = 321;  
        Integer f = 321;  
        int ee = 321;  
        int ff = 321;  
        Long g = 3L;  
        System.out.println(c==d);  //true, 原因：c会被建立在常量池中（栈），
//        所以d建立的时候会先搜索常量池中有无 3，有的话直接把已经生成对象的地址赋给d，c与d的地址是一致的
        System.out.println(a==aa); //  False, aa是通过new关键字建立的，会存放在堆中，地址与a的不一致
        System.out.println(a.equals(aa));  // true, 包装型的对象的equals方法同String的equals方法一致，都是比较内容
        System.out.println(e==f);  // False , 对于Integer类型，常量池中只维护 -128到127之间的数值，其他数值会通过new来创建
        System.out.println(ee==ff);  // true
        System.out.println(c==(a+b));  // true +号操作的时候会将a， b拆箱，进行整数加法， ==的时候会将c进行拆箱成为整数，两个整数比较值的内容大小相等
        System.out.println(c.equals(a+b));  //true +号操作的时候会将a， b拆箱，进行整数加法，equals的时候，会将a+b的整数值进行装箱，两个对象比较值的大小
        System.out.println(g==(a+b));   // true ,原理同c==(a+b)
        System.out.println(g.equals(a+b)); // False, +号操作的时候会将a， b拆箱，进行整数加法，equals的时候，会将a+b的整数值进行装箱, 两个对象的类型不一致，所以false

自动装箱的缺点：

自动装箱有一个问题，那就是在一个循环中进行自动装箱操作的情况，如下面的例子就会创建多余的对象，影响程序的性能。

Integer sum = 0;
 for(int i=1000; i<5000; i++){
   sum+=i; 
}

此时，当执行 sum+=i时，首先会自动拆箱成整数类型进行运算，然后赋值给sum的时候，又会自动装箱，浪费效率，所以需要注意