Java中自动装箱与拆箱
一、什么是封装类？
Java中存在基础数据类型，但是在某些情况下，我们要对基础数据类型进行对象的操作，例如，集合中只能存在对象，而不能存在基础数据类型，于是便出现了包装器类。包装器类型就是对基本数据类型进行了封装，使之成为一个对象，每一个基本数据类型都对应一种包装器类型。
二、什么是装箱与拆箱
将基本数据类型变为包装器类，便是装箱，将包装器类转为基本数据类型就是拆箱。相面以Integer为例：
public static void main(String[] args){ //自动装箱 Integer a = 100; //自动拆箱 int b = a; }
实际上，Integer在装箱过程中调用了Integer中的valueOf()方法，拆箱为int时调用了Integer中的intValue()方法，源码如下：
public static Integer valueOf(int i) { assert IntegerCache.high >= 127; if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); }
public int intValue() { return value; }
这便是装箱与拆箱的底层执行过程，其它包装器类类似。
三、自动装箱与拆箱中的一些问题
问题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); //true System.out.println(i3==i4); //false } }
通过分析valueOf()方法我们知道，当值为-128到127之间时，返回return IntegerCache.cache[i + (-IntegerCache.low)];当不在这个区间时，返回return new Integer(i);那么IntegerCache.cache[i + (-IntegerCache.low)]又是什么呢？继续追踪源码：
private static class IntegerCache { static final int low = -128; static final int high; static final Integer cache[]; static { // high value may be configured by property int h = 127; String integerCacheHighPropValue = sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high"); if (integerCacheHighPropValue != null) { int i = parseInt(integerCacheHighPropValue); i = Math.max(i, 127); // Maximum array size is Integer.MAX_VALUE h = Math.min(i, Integer.MAX_VALUE - (-low) -1); } 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() {} }
从上面代码可以看出Integer类中提前就初始化了一个Integer数组，范围为-128到127。回到上面的题目：i1==i2=100返回true是因为范围属于-128到127，直接返回cache[]数组中的对象，属于同一个对象，==运算符比较对象，从而返回true，而200超过了这个范围，直接返回new Integer(),因此属于两个不同的对象，结果为false。
问题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); //false System.out.println(i3==i4); //false } }
上面的代码中的结果与Integer类型的结果大相径庭，原因还得从源码中找。
public static Double valueOf(double d) { return new Double(d); }
因此返回false理所当然。
总结一下：
Integer派别：Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。
Double派别：Double、Float的valueOf方法的实现是类似的。每次都返回不同的对象。
Integer派别的范围：
问题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);//true System.out.println(i3==i4);//true } }
以上代码又是林外一种情况，继续追踪源码
public static Boolean valueOf(boolean b) { return (b ? TRUE : FALSE); }
/** * The {@code Boolean} object corresponding to the primitive * value {@code true}. */ public static final Boolean TRUE = new Boolean(true); /** * The {@code Boolean} object corresponding to the primitive * value {@code false}. */ public static final Boolean FALSE = new Boolean(false);
分析可知，TRUE和FALSE是两个final对象，因此i1、i2和i3、i4始终指向同一个对象的地址，因此返回true。
问题4：
public static void main(String[] args) { Integer num1 = 400; int num2 = 400; System.out.println(num1 == num2); //true System.out.println(num1.equals(num2)); //true }
可见num1 == num2进行了拆箱操作。equals源码如下：
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}
我们知道equal比较的是内容本身，并且我们也可以看到equal的参数是一个Object对象，我们传入的是一个int类型，所以首先会进行装箱，然后比较，之所以返回true，是由于它比较的是对象里面的value值。
问题5：
public static void main(String[] args) { Integer num1 = 100; int num2 = 100; Long num3 = 200l; System.out.println(num1 + num2); //200 System.out.println(num3 == (num1 + num2)); //true System.out.println(num3.equals(num1 + num2)); //false }
当一个基础数据类型与封装类进行==、+、-、*、/运算时，会将封装类进行拆箱，对基础数据类型进行运算。
对于num3.equals(num1 + num2)为false的原因很简单，我们还是根据代码实现来说明：
public boolean equals(Object obj) { if (obj instanceof Long) { return value == ((Long)obj).longValue(); } return false; }
它必须满足两个条件才为true：
1、类型相同
2、内容相同
上面返回false的原因就是类型不同。
问题6：
public static void main(String[] args) { int num1 = 100; int num2 = 200; long mum3 = 300; System.out.println(mum3 == (num1 + num2)); //true }
当 “==”运算符的两个操作数都是包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）。
问题7：
public static void main(String[] args) { Integer integer100=null; int int100=integer100; }
这两行代码是完全合法的，完全能够通过编译的，但是在运行时，就会抛出空指针异常。其中，integer100为Integer类型的对象，它当然可以指向null。但在第二行时，就会对integer100进行拆箱，也就是对一个null对象执行intValue()方法，当然会抛出空指针异常。所以，有拆箱操作时一定要特别注意封装类对象是否为null。
