Java自动装箱与拆箱
原创
2016-03-04 13:47:48
作者: 朱小厮
Java
10 分钟 读完 (大约 1496 个字) 0次访问

Java自动装箱与拆箱

  自动装箱与拆箱机制在实际使用中非常常见，不过也特别容易出错，博主在面对下面一道题的时候自信满满，可还是没有能够全对，所以写下这篇博文，给自己对自动装箱与拆箱机制做一下知识巩固，也给各位朋友做一下参考。

  首先有这样一道题，给出下面代码的输出结果：

public class AutoBoxing
{
    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);
        System.out.println(e==f);
        System.out.println(c==(a+b));
        System.out.println(c.equals(a+b));
        System.out.println(g==(a+b));
        System.out.println(g.equals(a+b));
    }
}

  运行结果：

true
false
true
true
true
false

  如果你看到这边，答案都正确，而且没有丝毫的疑问，那么对于你来说这篇博文就此结束了，如果没有，请继续翻阅。

  首先从最基础的开始讲起，首先通过反编译来看一看自动装箱和拆箱的过程：

  首先看如下一段程序：

public class AutoBoxing2
{
    public static void main(String[] args)
    {
        Integer a = 1;
        Integer b = 2;
        Integer c = a+b;
    }
}

  反编译结果为：（如果对于java反编译不太了解的朋友可以先看一下《通过Java反编译揭开一些问题的真相》）

public jvm.optimize.AutoBoxing2();
    flags: ACC_PUBLIC

    Code:
      stack=1, locals=1, args_size=1
         0: aload_0       
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return        
      LineNumberTable:
        line 3: 0

  public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC

    Code:
      stack=2, locals=4, args_size=1
         0: iconst_1      
         1: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
         4: astore_1      
         5: iconst_2      
         6: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
         9: astore_2      
        10: aload_1       
        11: invokevirtual #3                  // Method java/lang/Integer.intValue:()I
        14: aload_2       
        15: invokevirtual #3                  // Method java/lang/Integer.intValue:()I
        18: iadd          
        19: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
        22: astore_3      
        23: return        
      LineNumberTable:
        line 8: 0
        line 9: 5
        line 10: 10
        line 11: 23

  可以看到Integer a=1实际上自动装箱为Integer a = Integer.valueOf(1),而在进行a+b的时候可以看到进行了自动拆箱，将a拆箱为Integer.intValue();然后将a和b的int值相加，相加之后有进行了自动装箱：Integer c=Integer.valueOf(3).

  接下来我们就可以上面题目中给出的 System.out.println(c==d);和System.out.println(e==f);他们分别的结果为true和false。

  知道Integer会缓存-128至127的朋友估计这两条语句的输出结果都能答对。

  如果没有答对，请看解析：

  Integer c=3；会自动装箱为Integer c = Integer.valueOf(3),那么看一下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);
    }
    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) -1);
            }
            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会缓存-128值127的内容，如果值在这个区间之内（比如c和d），那么就会返回IntegerCache中的引用，所以Integer c= Integer d = IntegerCache.cache[3+(–128)] = IntegerCache.cache[131], c和d是相等的。

  但是如果超过这个区间，比如e和f，则Integer e = new Integer(321); Integer f = new Integer(321);new出来的自然是在堆中新开辟的内存，两份地址不同，自然e和f不同，也就是如果遇到这样的情况：

Integer m = new Integer(2);
Integer n = new Integer(2);
System.out.println(m==n);

  那么输出的结果是false（如果Integer m=2； Intger n=2则m和n相同）

  接着再说System.out.println(c==(a+b));

  我们看如下代码：

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

  反编译之后：

  0: iconst_1      
 1: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
 4: astore_1      
 5: iconst_2      
 6: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
 9: astore_2      
10: iconst_3      
11: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
14: astore_3      
15: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
18: aload_3       
19: invokevirtual #4                  // Method java/lang/Integer.intValue:()I
22: aload_1       
23: invokevirtual #4                  // Method java/lang/Integer.intValue:()I
26: aload_2       
27: invokevirtual #4                  // Method java/lang/Integer.intValue:()I
30: iadd          
31: if_icmpne     38
34: iconst_1      
35: goto          39
38: iconst_0      
39: invokevirtual #5                  // Method java/io/PrintStream.println:(Z)V
42: return

  可以看到实际在c==(a+b）的时候是执行拆箱机制，实际上就是在运算3==2+1,当然就是true咯。

  继续说明: System.out.println(c.equals(a+b));

  同样看一下c.equals(a+b)反编译的结果（篇幅限制，只截取部分相关的结果）：

19: aload_1       
20: invokevirtual #4                  // Method java/lang/Integer.intValue:()I
23: aload_2       
24: invokevirtual #4                  // Method java/lang/Integer.intValue:()I
27: iadd          
28: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
31: invokevirtual #5                  // Method java/lang/Integer.equals:(Ljava/lang/Object;)Z

  可以看到a+b先拆箱为int再相加之后再装箱为Integer型与c进行equals比较，那么我们再看一下equals()方法的源码：

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

  通过查看源码可知此条语句的输出结果为true。

  最后来看一下System.out.println(g==(a+b));和System.out.println(g.equals(a+b));两条语句。

  System.out.println(g==(a+b));由前面的推论可知最后g拆箱为long型，a+b为int型，基础类型int可以自动升级为long，所以输出为true。

  对于System.out.println(g.equals(a+b));可以看一下Long的equals()方法。

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

  对于(a+b)来说是Integer类型，所以返回false.

  鉴于包装类的“==”运算在不遇到算术运算的情况下不会自动拆箱，以及它们equals()方法不处理数据转型的关系，博主建议在实际编码中要尽量避免这样使用自动装箱与拆箱机制。

欢迎支持笔者的作品《深入理解Kafka: 核心设计与实践原理》和《RabbitMQ实战指南》，同时欢迎关注笔者的微信公众号：朱小厮的博客（ID: hiddenkafka）。
本文作者： 朱小厮
本文链接： http://honeypps.com/java/java-autoboxing-and-unboxing/
版权声明： 未经本人允许，不得擅自转载、修改或用于其它任何用途！

Java
Javac编译过程
通过Java反编译揭开一些问题的真相

评论

关注我

最新文章

标签云

ActiveMQ Annotation Binlog CAP Canal ChaosBlade Cobra Collection Cookie Docker ElasticSearch GTID Git Golang HTTP IO Iliffe向量 InnoDB JDK JMX JSch Java Jedis Kafka Keepalived Kong LAMP LVS Lambda Linux Memcached MySQL Mybatis NIO Nginx OpenReplicator OpenResty Oracle POI ProcessBuilder RXTXComm RabbitMQ Raft Redis RocketMQ Scala Session Shell Solr Spark Spring Spring Cloud Gateway SpringMVC TCP ThreadLocal Tomcat Traefik UDP VMTools VRRP VSphere XManager Zookeeper Zuul iptables logback sbt 一致性 串口 事务 共识 分布式 分布式锁 分表分库 列优先 单例 友链 后端 图数据库 多线程 安全 招聘 数据库 文件句柄 杂谈 架构 消息队列 混沌工程 畅言 算法 缓存 网关 网络 网络分区 行优先 设计模式 零拷贝 面试

分类

归档

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×