Java學習之自動裝箱和自動拆箱原始碼分析

@Test
public void boxingTest() {

Integer i1 = 17;
Integer i2 = 17;

Integer i3 = 137;
Integer i4 = 137;

System.out.println(i1 == i2);
11 System.out.println(i3 == i4);
}

輸出：

true
false

/**
* Returns an {@code Integer} instance representing the specified
* {@code int} value. If a new {@code Integer} instance is not
* required, this method should generally be used in preference to
* the constructor {@link #Integer(int)}, as this method is likely
* to yield significantly better space and time performance by
* caching frequently requested values.
*
* This method will always cache values in the range -128 to 127,
* inclusive, and may cache other values outside of this range.
*
* @param i an {@code int} value.
* @return an {@code Integer} instance representing {@code i}.
* @since 1.5
*/
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}

Note:

true
false
true
true

 
/**
* Compares this object to the specified object. The result is
* {@code true} if and only if the argument is not
* {@code null} and is an {@code Integer} object that
* contains the same {@code int} value as this object.
*
* @param obj the object to compare with.
* @return {@code true} if the objects are the same;
* {@code false} otherwise.
*/
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}

Note:

1. Integer、Short、Byte、Character、Long這幾個包裝類的intValue方法的實現是類似的；
2. Double、Float的intValue方法的實現是類似的。
3. Boolean的booleanValue方法的實現和intValue方法的實現也是類似的。

裝箱拆箱綜合清單：

public static void main(String args[]) {

Integer a = 1;
Integer b = 2;
Integer c = 3;
Integer d = 3;
Integer e = 321;
Integer f = 321;

Long g = 3L;
Long h = 2L;

// 會自動拆箱（會呼叫intValue方法）
System.out.println(c==d);
// 會自動拆箱後再自動裝箱
System.out.println(e==f);
// 雖然“==”比較的是引用的是否是同一物件，但這裡有算術運算，如果該引用為包裝器型別則會導致自動拆箱
System.out.println(c==(a+b));
// equals 比較的是引用的物件的內容（值）是否相等，但這裡有算術運算，如果該引用為包裝器型別則會導
 // 致自動拆箱，再自動裝箱
// a+b觸發自動拆箱得到值後，再自動裝箱與c比較
System.out.println(c.equals(a+b));
// 首先a+b觸發自動拆箱後值為int型，所以比較的是值是否相等
System.out.println(g==(a+b));
// 首先a+b觸發自動拆箱後值為int型，自動裝箱後為Integer型，然後g為Long型
System.out.println(g.equals(a+b));
// 首先a+h觸發自動拆箱後值為long型，因為int型的a會自動轉型為long型的g然後自動裝箱後為Long型，
 // 而g也為Long型
System.out.println(g.equals(a+h));

}

輸出：

true
false
true
true
true
false
true