装箱与拆箱
装箱：Java为每种基本数据类型都提供了对应的包装器类型，从Java SE5开始就提供了自动装箱的特性，简单来说， 自动将基本数据类型转换为包装器类型
拆箱：跟装箱对应，就是自动将包装器类型转换为基本数据类型，简单来说拆箱就是自动将包装器类型转换为基本数据类型
自动装箱与拆箱：因为装箱与拆箱是自动进行的不需要人为干预，所以被称为自动装箱与拆箱
基本数值类型与包装器类的对象关系：
2.png
例：定义一个Integer对象，数值为10
java5之前：
Integer i = new Integer(10);
java5之后：
Integer i = 10;
如果此时需要一个int 类型值为10的变量：
int n = i //自动拆箱
装箱与拆箱的实现方式
例：
public static void main(String[] args) {
Integer i = 10;
int n = i;
}
反编译后的.class文件
3.png
从反编译的字节码可以看出，在装箱的时候，自动调用Integer的valueOf方法，在拆箱的时候自动调用Integer的intValue方法
所以，装箱的过程是通过valueOf实现的，拆箱的过程是通过xxxValue实现的，其中xxx是相对应的基本数据类型
包装类的缓存数组
所有的包装类都提供了对象的缓存，目的是预先创建将来可能会频繁使用的包装类对象，当使用的对象在缓存范围中，就可以直接从缓存中获取
包装类中，缓存的对应范围：
| 包装类型 | 基本数据类型 | 缓存对象（基本数据类型值） |
|---|---|---|
| Boolean | boolean | true,false（全部值） |
| Byte | byte | -128~127（全部值） |
| Short | short | -128~127 |
| Character | char | 0~127 |
| Integer | int | -128~127（默认为127） |
| Long | long | -128~127 |
| Float | float | 无缓存值 |
| Double | double | 无缓存值 |
例：
public static void main(String[] args) {
Integer i1 = 100;
Integer i2 = 100;
Integer i3 = 200;
Integer i4 = 200;
System.out.println(i1 == i2);
System.out.println(i3 == i4);
}
运行结果
true
false
由运行结果可以看出，i1和i2指向了相同的对象，i3和i4指向了不同的对象
为什么会产生这样的结果？
先看看Integer中的valueOf方法和静态内部类IntegerCache的实现
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
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) {
try {
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);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
从两段代码中可以看出，如果在valueOf方法创建对象时，数值值[-128,127]之间，就会立即返回IntegerCache.cache中已经存在的对象引用，否者将会新建立一个Integer对象返回，所以之前的代码中，i1与i2的数值都是100，它们获取的都是缓存中已经存在的对象，而i3和i4的数值不在IntegerCache类所指定的范围内，所以分别创建了两个对象，所以不等
在来看看下面的代码：
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);
System.out.println(i3==i4);
}
执行结果
false
false
运行结果和之前的Integer包装类并不相同，在本文开头给出了一个表格，其中标明了两个浮点类型Double和Float他们是不存在缓存值的（某个范围的整数有限，但浮点数却不是），所以上面的i1-i4都分别创建了4个不同的对象
public static void main(String[] args) {
Boolean i1 = false;
Boolean i2 = false;
Boolean i3 = true;
Boolean i4 = true;
System.out.println(i1==i2);
System.out.println(i3==i4);
}
执行结果：
true
true
从结果可以看出，i1与i2，i3与i4都指向了相同的对象，至于结果为什么是这样，可以看看Boolean类的源码：
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了
拆装箱中的三目运算符
示例：
public class Test {
public static void main(String[] args) {
TestBox testBox = new TestBox();
int result = testBox != null? testBox.getNum() : 0;
}
}
class TestBox{
Integer num;
public Integer getNum(){
return num;
}
}
在执行以上代码的时候发生NullPointerException，在对代码进行反编译后发现：
t1.png
编译器自动进行了intValue方法，也就是拆箱操作，导致NullPointerException，也许可能是两个结果中有一个为基本类型导致另一个包装类型自动拆箱，所以代码修改为
int result = testBox != null? testBox.getNum() : new Integer(0);
再次运行后发现依然出现NullPointerException，反编译后发现代码有变，但是依然出现了intValue，可以看出这是由于等式左边int类型结果造成的
t2.png
再次修改代码：
Integer result = testBox != null? testBox.getNum() : new Integer(0);
发现运行通过，没有报任何异常，再次反编译发现
t3.png
编译器没有偷偷的执行intValue操作了
所以，如果三目运算符中？之后的两个等式其中一个为包装类型另一个不为包装类型此时要注意包装类型的自动拆箱，如果两个等式都为包装类型，则没有自动拆箱操作（前提是返回的结果类型也为包装类型而不是基本类型）
网友评论