0. Thanks
1. 什么是自動裝箱和拆箱
在Java1.5下進(jìn)行過編程的話，你一定不會陌生這一點(diǎn)曙旭，你不能直接地向集合(Collections)中放入原始類型值擦秽，因?yàn)榧现唤邮諏ο蠼徊ァＭǔ＿@種情況下你的做法是，將這些原始類型的值轉(zhuǎn)換成對象，然后將這些轉(zhuǎn)換的對象放入集合中梨树。使用Integer,Double,Boolean等這些類我們可以將原始類型值轉(zhuǎn)換成對應(yīng)的對象葬荷，但是從某些程度可能使得代碼不是那么簡潔精煉涨共。為了讓代碼簡練，Java 1.5引入了具有在原始類型和對象類型自動轉(zhuǎn)換的裝箱和拆箱機(jī)制宠漩。但是自動裝箱和拆箱并非完美举反，在使用時需要有一些注意事項(xiàng)，如果沒有搞明白自動裝箱和拆箱扒吁，可能會引起難以察覺的bug火鼻。
自動裝箱
就是Java自動將原始類型值轉(zhuǎn)換成對應(yīng)的對象室囊，比如將int的變量轉(zhuǎn)換成Integer對象，這個過程叫做裝箱拆箱
將Integer對象轉(zhuǎn)換成int類型值魁索，這個過程叫做拆箱融撞。
這里的裝箱和拆箱是自動進(jìn)行的非人為轉(zhuǎn)換，所以就稱作為自動裝箱和拆箱粗蔚。原始類型byte,short,char,int,long,float,double和boolean對應(yīng)的封裝類為Byte,Short,Character,Integer,Long,Float,Double,Boolean尝偎。
2. 何時發(fā)生自動裝箱和拆箱
自動裝箱和拆箱在Java中很常見，比如我們有一個方法鹏控，接受一個對象類型的參數(shù)致扯，如果我們傳遞一個原始類型值，那么Java會自動講這個原始類型值轉(zhuǎn)換成與之對應(yīng)的對象当辐。最經(jīng)典的一個場景就是當(dāng)我們向ArrayList這樣的容器中增加原始類型數(shù)據(jù)時或者是創(chuàng)建一個參數(shù)化的類抖僵，比如下面的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
而對比在以前（java-1.5）的時候：
//before autoboxing
Integer iObject = Integer.valueOf(3);
Int iPrimitive = iObject.intValue()
//after java5
Integer iObject = 3; //autobxing - primitive to wrapper conversion
int iPrimitive = iObject; //unboxing - object to primitive conversion
3. 自動裝箱帶來的問題
性能問題
自動裝箱有一個問題缘揪，那就是在一個循環(huán)中進(jìn)行自動裝箱操作的情況耍群，如下面的例子就會創(chuàng)建多余的對象，影響程序的性能找筝。
Integer sum = 0;
for(int i=1000; i<5000; i++){
sum+=i;
}
上面的代碼sum+=i可以看成sum = sum + i蹈垢，但是+這個操作符不適用于Integer對象，首先sum進(jìn)行自動拆箱操作呻征，進(jìn)行數(shù)值相加操作耘婚，最后發(fā)生自動裝箱操作轉(zhuǎn)換成Integer對象。其內(nèi)部變化如下
int result = sum.intValue() + i;
Integer sum = new Integer(result);
由于我們這里聲明的sum為Integer類型陆赋，在上面的循環(huán)中會創(chuàng)建將近4000個無用的Integer對象沐祷，在這樣龐大的循環(huán)中，會降低程序的性能并且加重了垃圾回收的工作量攒岛。因此在我們編程時赖临，需要注意到這一點(diǎn)，正確地聲明變量類型灾锯，避免因?yàn)樽詣友b箱引起的性能問題兢榨。
重載
當(dāng)重載遇上自動裝箱時，情況會比較有些復(fù)雜顺饮，可能會讓人產(chǎn)生有些困惑吵聪。在1.5之前，value(int)和value(Integer)是完全不相同的方法兼雄，開發(fā)者不會因?yàn)閭魅胧莍nt還是Integer調(diào)用哪個方法困惑吟逝，但是由于自動裝箱和拆箱的引入，處理重載方法時稍微有點(diǎn)復(fù)雜赦肋。一個典型的例子就是ArrayList的remove方法块攒，它有remove(index)和remove(Object)兩種重載励稳，我們可能會有一點(diǎn)小小的困惑，其實(shí)這種困惑是可以驗(yàn)證并解開的囱井，通過下面的例子我們可以看到驹尼，當(dāng)出現(xiàn)這種情況時，不會發(fā)生自動裝箱操作庞呕。
public void test(int num){
System.out.println("method with primitive argument");
}
public void test(Integer num){
System.out.println("method with wrapper argument");
}
//calling overloaded method
AutoboxingTest autoTest = new AutoboxingTest();
int value = 3;
autoTest.test(value); //no autoboxing
Integer iValue = value;
autoTest.test(iValue); //no autoboxing
Output:
method with primitive argument
method with wrapper argument
對象相等比較
這是一個比較容易出錯的地方新翎，==可以用于原始值進(jìn)行比較，也可以用于對象進(jìn)行比較千扶，當(dāng)用于對象與對象之間比較時料祠，比較的不是對象代表的值，而是檢查兩個對象是否是同一對象澎羞，這個比較過程中沒有自動裝箱發(fā)生。進(jìn)行對象值比較不應(yīng)該使用==敛苇，而應(yīng)該使用對象對應(yīng)的equals方法妆绞。看一個能說明問題的例子枫攀。
public class AutoboxingTest {
public static void main(String args[]) {
// Example 1: == comparison pure primitive – no autoboxing
int i1 = 1;
int i2 = 1;
System.out.println("i1==i2 : " + (i1 == i2)); // true
// Example 2: equality operator mixing object and primitive
Integer num1 = 1; // autoboxing
int num2 = 1;
System.out.println("num1 == num2 : " + (num1 == num2)); // true
// Example 3: special case - arises due to autoboxing in Java
Integer obj1 = 1; // autoboxing will call Integer.valueOf()
Integer obj2 = 1; // same call to Integer.valueOf() will return same
// cached Object
System.out.println("obj1 == obj2 : " + (obj1 == obj2)); // true
// Example 4: equality operator - pure object comparison
Integer one = new Integer(1); // no autoboxing
Integer anotherOne = new Integer(1);
System.out.println("one == anotherOne : " + (one == anotherOne)); // false
}
}
Output:
i1==i2 : true
num1 == num2 : true
obj1 == obj2 : true
one == anotherOne : false
值得注意的是第三個小例子括饶，這是一種極端情況。obj1和obj2的初始化都發(fā)生了自動裝箱操作来涨。但是處于節(jié)省內(nèi)存的考慮图焰，JVM會緩存-128到127的Integer對象。因?yàn)閛bj1和obj2實(shí)際上是同一個對象蹦掐。所以使用”==“比較返回true技羔。
第四個例子，通過new integer的方式來新建的對象卧抗，不會發(fā)生自動裝箱藤滥，所以，生成的是新的兩個對象社裆。
自動裝箱會引發(fā)混亂而容易帶來空指針異常
另一個需要避免的問題就是混亂使用對象和原始數(shù)據(jù)值拙绊，一個具體的例子就是當(dāng)我們在一個原始數(shù)據(jù)值與一個對象進(jìn)行比較時，如果這個對象沒有進(jìn)行初始化或者為Null泳秀，在自動拆箱過程中obj.xxxValue标沪，會拋出NullPointerException,如下面的代碼
private static Integer count;
//NullPointerException on unboxing
if( count <= 0){
System.out.println("Count is not started yet");
}
緩存的對象
這個問題就是我們上面提到的極端情況，在Java中嗜傅，會對-128到127的Integer對象進(jìn)行緩存金句，當(dāng)自動裝箱創(chuàng)建新的Integer對象時，如果符合這個這個范圍磺陡，并且已有存在的相同值的對象趴梢，則返回這個對象漠畜，否則創(chuàng)建新的Integer對象。
Integer obj1 = 128; // autoboxing will call Integer.valueOf()
Integer obj2 = 128;
System.out.println("obj1 == obj2 : " + (obj1 == obj2)); // false
Integer obj1 = 127; // autoboxing will call Integer.valueOf()
Integer obj2 = 127;
System.out.println("obj1 == obj2 : " + (obj1 == obj2)); // true
這兩段代碼對得到不同的結(jié)果坞靶，也就是上面所說的極端情況憔狞。
4. 部分源碼分析
自動裝箱時編譯器調(diào)用valueOf將原始類型值轉(zhuǎn)換成對象，同時自動拆箱時彰阴，編譯器通過調(diào)用類似intValue(),doubleValue()這類的方法將對象轉(zhuǎn)換成原始類型值瘾敢。
緩存的數(shù)量？
我們在源碼中可以找到有一段：
/**
* Returns a {@code Integer} instance for the specified integer value.
* <p>
* If it is not necessary to get a new {@code Integer} instance, it is
* recommended to use this method instead of the constructor, since it
* maintains a cache of instances which may result in better performance.
*
* @param i
* the integer value to store in the instance.
* @return a {@code Integer} instance containing {@code i}.
* @since 1.5
*/
public static Integer valueOf(int i) {
return i >= 128 || i < -128 ? new Integer(i) : SMALL_VALUES[i + 128];
}
/**
* A cache of instances used by {@link Integer#valueOf(int)} and auto-boxing
*/
private static final Integer[] SMALL_VALUES = new Integer[256];
static {
for (int i = -128; i < 128; i++) {
SMALL_VALUES[i + 128] = new Integer(i);
}
}
從源碼就看到尿这，數(shù)值是：[-128,127) 的時候簇抵，會直接返回緩存好的對象，否則就新建一個對象射众。
