包装类的自动装拆箱及Integer类的缓存区问题

jdk1.5后，出现了自动装箱和拆箱机制。即基本数据类型值可以赋值给基本数据类型的包装类，并可以和基本数据类型值直接运算。那么，这是如何实现的呢？看下面代码示例：

/**
*   基本数据类型的包装类，主要是提供了基本数据类型和字符串之间的转换方法
*   
*/

public class TestWrapClass {

    public static void testAuto () {


        Boolean flag = true;
        Integer i = 10;
        i+=3;


    }

    public static void testCache () {


        Integer i = 10;
        Integer j = 10;
        Integer a = 128;
        Integer b = 128;
        sop(i==j);
        sop(a==b);

    }

    public static void main(String[] args) {

        testAuto();
        testCache();

    }

    public static void sop(Object obj) {

        System.out.println(obj);
    }

}

使用javap -c TestWrapClass，查看反汇编后的代码，以testAuto为例：
public static void testAuto();
Code:
0: iconst_1
1: invokestatic #2; //Method java/lang/Boolean.valueOf:(Z)Ljava/lang/Boolean;
4: astore_0
5: bipush 10
7: invokestatic #3; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
10: astore_1
11: aload_1
12: invokevirtual #4; //Method java/lang/Integer.intValue:()I
15: iconst_3
16: iadd
17: invokestatic #3; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
20: astore_1
21: return
第1：Boolean flag = true在编译时自动调用Boolean类的valueOf（boolean b）的静态方法，返回Boolean对象后赋值。这就是自动装箱过程，i+=3时，首先调用Integer类的intValue方法，进行运算，这是自动拆箱的过程，然后调用Integer类的valueOf方法，进行自动装箱操作。参见第12：和第17：，这就是自动装拆箱的实现过程。
再看testCache方法，结果是：true false 。为什么呢？这就要说到Integer类的缓冲区。我们知道自动装箱是通过调用包装类的静态方法valueOf实现的，而查看Integer类的valueOf方法，发现：

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

当数值范围在-128——Integer缓冲区最大值（包括两者）时，会返回缓冲区中的Integer对象，否则会新建一个对象。那么，什么是Integer类的缓冲区呢？看下列代码：

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() {}
    }

发现这个缓存类就是定义在Integer类中的一个静态内部类，定义了两个属性：缓存区放置的最大int值和缓存Integer类型数组。如果系统配置（jvm配置）中通过：-XX:AutoBoxCacheMax= 确定了最大值，那么使用该最大值，但是限定缓存区的最大长度是int型最大值，所以最大值不超过：Integer.MAX_VALUE - -low。最后，初始化了int值从-128到最大值之间的一个Integer型数组。Integer类被加载时，就在方法区创建了一个这样的缓存区。自动装箱时，当数值范围在该缓存区范围内，无论调用多少次，都是返回该缓存区的一个Integer对象，而超出这个范围，则每次在堆区新建一个对象。