详解Java中的自动装箱拆箱

最新推荐文章于 2023-03-18 21:44:54 发布

ZCrainy

最新推荐文章于 2023-03-18 21:44:54 发布

阅读量253

点赞数

分类专栏： android 文章标签： java 自动装箱自动拆箱

本文链接：https://blog.csdn.net/WernerZeiss/article/details/107605956

版权

android 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

详解Java中的自动装箱拆箱

一段代码引发的问题

最近在学习一本关于java虚拟机的书，其中有一段关于自动装箱陷阱的示例代码如下：

    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;
        System.out.println(c == d);//true
        System.out.println(e == f);//false
        System.out.println(c == (a + b));//true
        System.out.println(c.equals(a + b));//true
        System.out.println(g == (a + b));//true
        System.out.println(g.equals(a + b));//false
    }

作者并没有给出输出答案是如何，自己分析了一下，自认为应该没错，然后实践运行出来傻眼了，暗恨自己以前囫囵吞枣，没有彻底搞清楚。所以花时间好好补补课。

概念

本质上自动装箱、拆箱只是Java语言中的语法糖，在Java里使用特别广泛。我们通过一个示例看一下这些语法糖在编译后发生的变化。

    public static void main(String[] args) {
        Integer a = 1;//自动装箱
        int b = a;//自动拆箱
    }

反编译class文件后如下：

  public static void main(java.lang.String[]);
    Code:
       0: iconst_1
       1: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       4: astore_1
       5: aload_1
       6: invokevirtual #3                  // Method java/lang/Integer.intValue:()I
       9: istore_2
      10: return

我们看到，在执行Integer a = 1;这句的时候，实际上执行的是Integer的静态方法valueOf()：

Integer a = Integer.valueOf(1);

在执行int b = a;时，执行的是Integer的静态方法intValue()：

int b = a.intValue();

这就是Java的自动状态、拆箱。

问题分析

我们看回示例代码的前两个打印：

Integer c = 3;
Integer d = 3;
Integer e = 321;
Integer f = 321;
System.out.println(c == d);//true
System.out.println(e == f);//false

what the fffffff…？都是对象进行比较，有毛的不一样？
这就是自动装箱中的一个陷阱了，我们根据字节码流程分析一下：
首先在上面的赋值操作中，我们知道是调用Integer类的valueOf(Object)方法生成Integer对象的：

Integer c = Integer.valueOf(3);

我们看一下这个valueOf()方法的实现：

    /**
     * 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);
    }

其实看注释我们也能看到，这个方法会缓存范围为-128到127的值，也就是如果i的值在此范围，将会从定义好的Integer对象数组中返回Integer对象，这样做可以减少对象的频繁创建。
IntegerCache是Integer中的私有静态内部类，我们看一下是怎么定义的：

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

可以清楚的看到Integer缓存数组cache[]的创建过程，预先创建并添加了-128到127范围内的Integer对象。因为3在缓存值范围内，c和d拿到的是缓存中相同的对象，而e和f因为值超出了范围，各自拿到的是新创建的对象，对象之间的“==”号比较的是地址，自然一个是true，一个是false。
下面分析第三四句打印：

Integer a = 1;
Integer b = 2;
Integer c = 3;
System.out.println(c == (a + b));//true
System.out.println(c.equals(a + b));//true

虽然这两句打印结果相同，但是操作方式是不一样的。我们看这两句打印的反编译class指令：

Code:
      80: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
      83: aload_3
      84: invokevirtual #8                  // Method java/lang/Integer.intValue:()I
      87: aload_1
      88: invokevirtual #8                  // Method java/lang/Integer.intValue:()I
      91: aload_2
      92: invokevirtual #8                  // Method java/lang/Integer.intValue:()I
      95: iadd
      96: if_icmpne     103
      99: iconst_1
     100: goto          104
     103: iconst_0
     104: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V
     107: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
     110: aload_3
     111: aload_1
     112: invokevirtual #8                  // Method java/lang/Integer.intValue:()I
     115: aload_2
     116: invokevirtual #8                  // Method java/lang/Integer.intValue:()I
     119: iadd
     120: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
     123: invokevirtual #9                  // Method java/lang/Integer.equals:(Ljava/lang/Object;)Z
     126: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V

第一句打印，根据84、88、92、95行我们看到，a、b、c都进行了拆箱操作，a和b拆箱后进行相加操作，跟拆箱后的c进行比较，结果自然是true。
第二句打印，根据112、116和119行，a和b分别拆箱然后相加，然后根据120行，相加后的值调用了Integer.valueOf()进行装箱。然后123行，c调用Integer的equals()方法进行比较。OK，那我们看一下这个方法的实现：

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

参数为object，如果类型同是Integer，则比较两者的基础值。否则返回false。
那第二句打印时true也就没有异议了。
下面分析打印第五六句：

Integer a = 1;
Integer b = 2;
Long g = 3L;
System.out.println(g == (a + b));//true
System.out.println(g.equals(a + b));//false

同样贴出两句打印语句的反编译指令：

     129: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
     132: aload         7
     134: invokevirtual #10                 // Method java/lang/Long.longValue:()J
     137: aload_1
     138: invokevirtual #8                  // Method java/lang/Integer.intValue:()I
     141: aload_2
     142: invokevirtual #8                  // Method java/lang/Integer.intValue:()I
     145: iadd
     146: i2l
     147: lcmp
     148: ifne          155
     151: iconst_1
     152: goto          156
     155: iconst_0
     156: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V
     159: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
     162: aload         7
     164: aload_1
     165: invokevirtual #8                  // Method java/lang/Integer.intValue:()I
     168: aload_2
     169: invokevirtual #8                  // Method java/lang/Integer.intValue:()I
     172: iadd
     173: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
     176: invokevirtual #11                 // Method java/lang/Long.equals:(Ljava/lang/Object;)Z
     179: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V

第一句打印，根据134、138、142、145，g拆箱后入栈，然后a和b拆箱进行相加，然后跟g进行比较，值相同，结果为true。
第二句打印，a和b拆箱后相加，然后对结果3进行装箱，然后Long类型的g调用Long.equals(Object obj)方法与该结果进行比较，我们看一下Long.equals()方法的实现：

    public boolean equals(Object obj) {
        if (obj instanceof Long) {
            return value == ((Long)obj).longValue();
        }
        return false;
    }

实现方式跟Integer如出一辙，如果比较对象是Long类型，则对基础值进行比较，否则返回false。这里因为结果3是Integer类型，所以是false。
分析完了上面那些，不知大家是否和我一样还有一些疑问？比如下面：

Integer c = 3;
int h = 3;
System.out.println(c == h);
System.out.println(c.equals(h));

我们可能都知道这两个打印结果都是true，但是他们背后又是怎么实现的呢？c和h比较，到底是装箱后的equals比较，还是拆箱后的值比较呢？Integer.equals(Object)这个方法参数类型是object，而我们传入的是基本数据类型int，这又是怎么处理的呢？
篇幅原因这里就不贴反编译码了，直接给出结论：第一句打印中，是对c拆箱后比较的。第二句中，会对h进行自动状态，然后通过equals(Object)方法比较。

总结

根据以上分析，我们可以得出一些结论：

如果是包装类之间的“==”运算，在没有算数运算的情况下不会自动拆箱，比较的是对象地址。遇到算数运算时会进行自动拆箱，比较数值。
如果是包装类和基本类型之间的"=="比较，包装类会拆箱后比较
包装类的equals(Object)方法是不处理数据转型关系的，如Long.equals(Integer.value(3))，类型不一致就会返回false。

ZCrainy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
详解Java中的自动装箱拆箱

详解Java中的自动装箱拆箱一段代码引发的问题最近在学习一本关于java虚拟机的书，其中有一段关于自动装箱陷阱的示例代码如下： public static void main(String[] args) { Integer a = 1; Integer b = 2; Integer c = 3; Integer d = 3; Integer e = 321; Integer f = 321;
复制链接

扫一扫

专栏目录