// 手動裝箱
int i = 10;
Integer integerObj = Integer.valueOf(i); // 方式一：推薦，使用了緩存（后面會講）
// 或者
Integer integerObj2 = new Integer(i);    // 方式二：已過時 (Deprecated)，不推薦

// 手動拆箱
Integer integerObj = new Integer(10);
int j = integerObj.intValue(); // 從 Integer 對象中取出 int 值

// 自動裝箱
int i = 10;
Integer integerObj = i; // 編譯器背后實(shí)際執(zhí)行的是：Integer integerObj = Integer.valueOf(i);

// 自動拆箱
Integer integerObj = new Integer(10);
int j = integerObj; // 編譯器背后實(shí)際執(zhí)行的是：int j = integerObj.intValue();

// 在 Java 5 之前，使用 ArrayList 非常麻煩
ArrayList list = new ArrayList();
list.add(Integer.valueOf(1)); // 手動裝箱
int value = (Integer) list.get(0)).intValue(); // 取出來是 Object，要強(qiáng)轉(zhuǎn)，再手動拆箱

// 在 Java 5 之后，有了泛型和自動裝箱/拆箱
ArrayList<Integer> list = new ArrayList<>();
list.add(1); // 自動裝箱：int -> Integer
int value = list.get(0); // 自動拆箱：Integer -> int。代碼清晰多了！

// 1. 方法調(diào)用時傳遞參數(shù)
public void processInteger(Integer i) { ... }
processInteger(5); // 自動裝箱，將 int 5 轉(zhuǎn)為 Integer

// 2. 運(yùn)算符運(yùn)算時
Integer a = 10;
Integer b = 20;
int c = a + b; // a 和 b 先自動拆箱為 int，相加后結(jié)果再自動裝箱賦給 Integer（如果接收類型是Integer）
// 等價于：int c = a.intValue() + b.intValue();

// 3. 三目運(yùn)算符中
boolean flag = true;
Integer i = flag ? 100 : 200; // 100和200都會被自動裝箱為Integer

Integer nullInteger = null;
int i = nullInteger; // 運(yùn)行時拋出 NullPointerException！
// 背后是：int i = nullInteger.intValue();

long start = System.currentTimeMillis();
Long sum = 0L; // 這里用的是包裝類 Long，會觸發(fā)自動裝箱
for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i; // 每次循環(huán)：i自動裝箱為Long，然后sum拆箱為long，相加后再裝箱為Long
}
long end = System.currentTimeMillis();
System.out.println("耗時：" + (end - start));
// 將 Long sum = 0L 改為 long sum = 0L，性能會有巨大提升。

public class Main{
    public static void main(Sring[] args){
        
            Integer i1 = 100;
            Integer i2 = 100;
            Integer i3 = 200;
            Integer i4 = 200;
            
            System.out.println(i1 == i2);
            System.out.println(i3 == i4);
    }
}

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

private static class IntegerCache {
        static final int high;
        static final Integer cache[];
 
        static {
            final int low = -128;
 
            // high value may be configured by property
            int h = 127;
            if (integerCacheHighPropValue != null) {
                // Use Long.decode here to avoid invoking methods that
                // require Integer's autoboxing cache to be initialized
                int i = Long.decode(integerCacheHighPropValue).intValue();
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - -low);
            }
            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() {}
    } 

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);
        System.out.println(i3==i4);
    }
 }

boolean flag = true;
Integer i = flag ? 100 : Integer.valueOf(200);
// 這沒問題，因?yàn)?100 和 Integer.valueOf(200) 類型“一致”（都是Integer對象）

Integer i = flag ? 100 : null;
// 當(dāng) flag 為 false 時，會發(fā)生什么？
// 編譯器認(rèn)為 100 是 int，null 是 Integer。為了類型一致，它會將 100 自動裝箱為 Integer，將 null 作為 Integer。
// 所以這里不會報錯，i 會被賦值為 null。

int j = flag ? 100 : Integer.valueOf(200);
// 這也沒問題，因?yàn)?Integer.valueOf(200) 會被自動拆箱為 int。

int k = flag ? 100 : null;
// 當(dāng) flag 為 false 時，會發(fā)生 NullPointerException！
// 因?yàn)榫幾g器需要得到一個 int 類型的結(jié)果，所以它會嘗試對 `null` 進(jìn)行自動拆箱，調(diào)用 null.intValue()。