Integer自动装箱细节分析

---

装箱 就是将基本的数据类型(比如int)封装成对象类型(比如Integer)。拆箱 就是将对象类型拆包装为基本类型。

装箱和拆箱操作为我们提供了很多便利。

• 包装类，如Integer给我们提供的友好的API方法，使我们可以快速完成数据类型之间的转换。
• Java是面向对象的，我们在Java中处理的绝大多数都是对象，在类似Map集合类等很多场合中，我们需要放入Integer这种对象类型。

很多情况下，编译器为我们自动完成了基本数据类型的拆箱和装箱操作。

public class TestInteger{    public static void main(String[] args){        int a1 = 127;    //auto-boxing        Integer i = a1;    //auto-unboxing        int b1 = i;    }}

下面，我们来看一段代码：

public class TestInteger{         public static void main(String[] args){            int a1 = 12;            //auto-boxing            Integer number1 = a1;            Integer number2 = a1;            System.out.println("number1==number2:"+ (number1==number2));            //out:number1==number2:true            int b1=128;            Integer number3 = b1;            Integer number4 = b1;            System.out.println("number3==number4:"+ (number3==number4));            //out:number3==number4:false        }}

通过编译,我们发现Integer类型在auto-boxing操作时,-128到127之间的int类型整数封装之后的对象是同一个,这个范围之外的int类型整数封装之后对象是不同的。通过后面的分析,我们可以知道：

-128到127这个范围,-128是固定的,上限127是我们可以通过Jvm参数配置的。

为什么会这样呢?我们通过这段程序的字节码分析这段程序编译的细节:

Microsoft Windows [版本 10.0.15063](c) 2017 Microsoft Corporation。保留所有权利。D:\JavaProject\SuperMarket\bin\com\javaexc\service>javap -c Test.classCompiled from "Test.java"public class com.javaexc\service.Test {  public com.javaexc\service.Test();    Code:       0: aload_0       1: invokespecial #8                  // Method java/lang/Object."<init>":()V       4: return  public static void main(java.lang.String[]);    Code:       0: bipush        12       2: istore_1       3: iload_1       4: invokestatic  #16                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;       7: astore_2       8: iload_1       9: invokestatic  #16                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;      12: astore_3      13: getstatic     #22                 // Field java/lang/System.out:Ljava/io/PrintStream;      16: new           #28                 // class java/lang/StringBuilder      19: dup      20: ldc           #30                 // String number1==number2:      22: invokespecial #32                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V      25: aload_2      26: aload_3      27: if_acmpne     34      30: iconst_1      31: goto          35      34: iconst_0      35: invokevirtual #35                 // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;      38: invokevirtual #39                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;      41: invokevirtual #43                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V      44: sipush        128      47: istore        4      49: iload         4      51: invokestatic  #16                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;      54: astore        5      56: iload         4      58: invokestatic  #16                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;      61: astore        6      63: getstatic     #22                 // Field java/lang/System.out:Ljava/io/PrintStream;      66: new           #28                 // class java/lang/StringBuilder      69: dup      70: ldc           #48                 // String number3==number4:      72: invokespecial #32                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V      75: aload         5      77: aload         6      79: if_acmpne     86      82: iconst_1      83: goto          87      86: iconst_0      87: invokevirtual #35                 // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;      90: invokevirtual #39                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;      93: invokevirtual #43                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V      96: return}

通过观察4、9、51、58这四行字节码我们发现，编译器调用Integer.valueOf()帮助我们完成自动装箱操作。

我们进一步阅读Integer.class文件，分析Integer.valueOf()实际上完成的工作:

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

当输入参数i满足i >= IntegerCache.low && i <= IntegerCache.high这个范围时,return的是IntegerCache.cache[]这个数组里的元素,否则return一个新的Integer对象。
那么IntegerCache.low 和 IntegerCache.high以及IntegerCache.cache[]分别是什么呢？我们继续看代码：

 /**     * Cache to support the object identity semantics of autoboxing for values between     * -128 and 127 (inclusive) as required by JLS.     *     * The cache is initialized on first usage.  The size of the cache     * may be controlled by the -XX:AutoBoxCacheMax=<size> option.     * During VM initialization, java.lang.Integer.IntegerCache.high property     * may be set and saved in the private system properties in the     * sun.misc.VM class.     */    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) {                int i = parseInt(integerCacheHighPropValue);                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() {}    }

我们看到IntegerCache.low 和 IntegerCache.high以及IntegerCache.cache[]都是static final修饰的，IntegerCache.low固定是-128，IntegerCache.high可以通过设置属性来修改，默认是127。

结论1:

int类型整数自动装箱时，当值在上述范围内时，返回的是IntegerCache.cache[]这个数组里的同一个元素。

这也就是-128到127之间的int类型整数自动封装成同一个对象的原因。这里的IntegerCache就是用来处理Integer自动装箱操作的。

在自动装箱时，当值在[–128,127]之间时,引用指向的都是内存中的同一个对象。如果超过这个范围,每次装箱都会new()一个新的对象。这样便加大了对简单数字的重复使用,在某些场景下可以优化我们代码的性能。

结论2:

值得说明的是,上述情况只有在我们使用自动装箱时,编译器自动调用Integer.valueOf()才会出现,如果我们采用new()来创建对象,每一次new()的对象都是一个新的对象。