装箱 & 拆箱

// 装箱, int -> Integer      valueOf()
Integer i = 10;  

// 拆箱,  Integer -> int      intValue()
int n = i;

 

经典笔试

// Integer i01 = 98 的时候, 会调用 Integer 的 valueOf 方法
Integer i01 = 98;

// 这是一个基本类型, 存储在栈中
int i02 = 98;

// 因为 IntegerCache 中已经存在此对象, 所以, 直接返回引用
Integer i03 = Integer.valueOf(98);

// 直接创建一个新的对象. 
Integer i04 = new Integer(98);


//  i01 是 Integer 对象,  i02 是 int , 这里比较的不是地址, 而是值.  Integer 会自动拆箱成 int , 然后进行值的比较. 所以, 为真. 
System.out.println(i01 == i02);   // true

// 因为 i03 返回的是 i01 的引用, 所以, 为真. 
System.out.println(i01 == i03);   // true

// 因为 i04 是重新创建的对象, 所以 i03,i04 是指向不同的对象, 因此比较结果为假. 
System.out.println(i03 == i04);   // false

// 因为 i02 是基本类型, 所以此时 i04 会自动拆箱, 进行值比较, 所以, 结果为真. 
System.out.println(i02 == i04);   // true

 

valueOf 方法

Integer i1 = 127;
Integer i2 = 127;

Integer i3 = 128;
Integer i4 = 128;

// true, 表明 i1 和 i2 指向的是同一个对象
System.out.println(i1 == i2);

// false, 表明 i3 和 i4 指向的是不同对象
System.out.println(i3 == i4);

解释说明： 在通过valueOf方法创建Integer对象的时候, 如果数值在[-128,127]之间, 便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象. 会直接从cache中取已经存在的对象, 所以i1和i2指向的是同一个对象, 而i3和i4则是分别指向不同的对象

注意： ​​Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的, Double、Float 的valueOf方法的实现是直接新建对象, 不用预设缓存​​

 

valueOf 方法源码

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;
        // -128 到 127 之间的整数将被缓存 
        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() {}
}