zoukankan      html  css  js  c++  java
  • Java中的拆箱与装箱

    以下是本文的目录大纲:

      一.什么是装箱?什么是拆箱?

      二.装箱和拆箱是如何实现的

      三.面试中相关的问题

    转载请标明原文链接:http://www.cnblogs.com/dolphin0520/p/3780005.html

    一.什么是装箱?什么是拆箱?

    拆箱就是自动将包装器类型转换为基本数据类型的过程。装箱就是自动将基本数据类型转换为包装器类型的过程

    Java为每种基本数据类型都提供了对应的包装器类型,在Java SE5之前,如果要生成一个数值为10的Integer对象,必须这样进行:

    Integer i = new Integer(10);

    而在从Java SE5开始就提供了自动装箱的特性,如果要生成一个数值为10的Integer对象,只需要这样就可以了:

    Integer i = 10;

    这个过程中会自动根据数值创建对应的 Integer对象,这就是装箱。

    那什么是拆箱呢?顾名思义,跟装箱对应,就是自动将包装器类型转换为基本数据类型:

    Integer i = 10;  //装箱
    int n = i;   //拆箱

    下表是基本数据类型对应的包装器类型:

    int(4字节) Integer
    byte(1字节) Byte
    short(2字节) Short
    long(8字节) Long
    float(4字节) Float
    double(8字节) Double
    char(2字节) Character
    boolean(未定) Boolean

    二.装箱和拆箱是如何实现的

    上一小节了解装箱的基本概念之后,这一小节来了解一下装箱和拆箱是如何实现的。

      我们就以Interger类为例,下面看一段代码:

    1 public class Main {
    2     public static void main(String[] args) {3          
    4         Integer i = 10;
    5         int n = i;
    6     }
    7 }

    反编译class文件之后得到如下内容:

     从反编译得到的字节码内容可以看出,在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。

    其他的也类似,比如Double、Character,不相信的朋友可以自己手动尝试一下。

    因此可以用一句话总结装箱和拆箱的实现过程:

    装箱过程是通过调用包装器的valueOf方法实现的,而拆箱过程是通过调用包装器的 xxxValue方法实现的。(xxx代表对应的基本数据类型)。

    三.面试中相关的问题

    虽然大多数人对装箱和拆箱的概念都清楚,但是在面试和笔试中遇到了与装箱和拆箱的问题却不一定会答得上来。下面列举一些常见的与装箱/拆箱有关的面试题。

    1.下面这段代码的输出结果是什么?

     1 public class Main {
     2     public static void main(String[] args) {
     3          
     4         Integer i1 = 100;
     5         Integer i2 = 100;
     6         Integer i3 = 200;
     7         Integer i4 = 200;
     8          
     9         System.out.println(i1==i2);
    10         System.out.println(i3==i4);
    11     }
    12 }

    事实上输出结果是:

    true
    false

    为什么会出现这样的结果?输出结果表明i1和i2指向的是同一个对象,而i3和i4指向的是不同的对象。此时只需一看源码便知究竟,下面这段代码是Integer的valueOf方法的具体实现:

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

    而其中IntegerCache类的实现为:

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

    从这2段代码可以看出,在通过valueOf方法创建Integer对象的时候,如果数值在[-128,127]之间,便返回指向IntegerCache.cache中已经存在的对象的引用;否则创建一个新的Integer对象。

    面的代码中i1和i2的数值为100,因此会直接从cache中取已经存在的对象,所以i1和i2指向的是同一个对象,而i3和i4则是分别指向不同的对象。

    2.下面这段代码的输出结果是什么?

    public class Main {
        public static void main(String[] args) {
             
            Double i1 = 100.0;
            Double i2 = 100.0;
            Double i3 = 200.0;
            Double i4 = 200.0;
             
            System.out.println(i1==i2);
            System.out.println(i3==i4);
        }
    }

    也许有的朋友会认为跟上面一道题目的输出结果相同,但是事实上却不是。实际输出结果为:

    false
    false

    看看上面的执行结果,跟Integer不一样,这样也不必奇怪,因为它们的valueOf实现不一样,结果肯定不一样,那为什么它们不统一一下呢? 

    这个很好理解,因为对于Integer,在(-128,128]之间只有固定的256个值,所以为了避免多次创建对象,我们事先就创建好一个大小为256的Integer数组SMALL_VALUES,所以如果值在这个范围内,就可以直接返回我们事先创建好的对象就可以了。

    但是对于Double类型来说,我们就不能这样做,因为它在这个范围内个数是无限的。 
    总结一句就是:在某个范围内的整型数值的个数是有限的,而浮点数却不是。

    所以在Double里面的做法很直接,就是直接创建一个对象,所以每次创建的对象都不一样。

    public static Double valueOf(double d) {
       return new Double(d);
     }

     3.下面这段代码输出结果是什么:

    public class Main {
        public static void main(String[] args) {
             
            Boolean i1 = false;
            Boolean i2 = false;
            Boolean i3 = true;
            Boolean i4 = true;
             
            System.out.println(i1==i2);
            System.out.println(i3==i4);
        }
    }

    输出结果是:

    true
    true

    至于为什么是这个结果,同样地,看了Boolean类的源码也会一目了然。下面是Boolean的valueOf方法的具体实现:

    public static Boolean valueOf(boolean b) {
            return (b ? TRUE : FALSE);
        }

    而其中的 TRUE 和FALSE又是什么呢?在Boolean中定义了2个静态成员属性:

    public static final Boolean TRUE = new Boolean(true);
    
        /** 
         * The <code>Boolean</code> object corresponding to the primitive 
         * value <code>false</code>. 
         */
        public static final Boolean FALSE = new Boolean(false);

    4.谈谈Integer i = new Integer(xxx)和Integer i =xxx;这两种方式的区别。

    当然,这个题目属于比较宽泛类型的。但是要点一定要答上,我总结一下主要有以下这两点区别:

    1)第一种方式不会触发自动装箱的过程;而第二种方式会触发;

    2)在执行效率和资源占用上的区别。第二种方式的执行效率和资源占用在一般性情况下要优于第一种情况(注意这并不是绝对的)。

    5.下面程序的输出结果是什么?

    public class Main {
        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;
            Long h = 2L;
             
            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
            System.out.println(g.equals(a+h));  //true
        }
    }

    先别看输出结果,读者自己想一下这段代码的输出结果是什么。这里面需要注意的是:当 "=="运算符的两个操作数都是 包装器类型的引用,则是比较指向的是否是同一个对象,而如果其中有一个操作数是表达式(即包含算术运算)则比较的是数值(即会触发自动拆箱的过程)。另外,对于包装器类型,equals方法并不会进行类型转换。明白了这2点之后,上面的输出结果便一目了然:

    第一个和第二个输出结果没有什么疑问。第三句由于  a+b包含了算术运算,因此会触发自动拆箱过程(会调用intValue方法),因此它们比较的是数值是否相等。。而对于c.equals(a+b)会先触发自动拆箱过程,再触发自动装箱过程,也就是说a+b,会先各自调用intValue方法,得到了加法运算后的数值之后,便调用Integer.valueOf方法,再进行equals比较。同理对于后面的也是这样,不过要注意倒数第二个和最后一个输出的结果(如果数值是int类型的,装箱过程调用的是Integer.valueOf;如果是long类型的,装箱调用的Long.valueOf方法)。

    上面把几种情况都介绍到了,下面来进一步讨论其他情况。

    Integer num1 = 400;  
    int num2 = 400;  
    System.out.println(num1 == num2); //true
    说明num1 == num2进行了拆箱操作
    Integer num1 = 100;  
    int num2 = 100;  
    System.out.println(num1.equals(num2));  //true

    我们先来看看equals源码:

    @Override
    public boolean equals(Object o) {
         return (o instanceof Integer) && (((Integer) o).value == value);
    }

    我们指定equal比较的是内容本身,并且我们也可以看到equal的参数是一个Object对象,我们传入的是一个int类型,所以首先会进行装箱,然后比较,之所以返回true,是由于它比较的是对象里面的value值。

    Integer num1 = 100;  
    int num2 = 100;  
    Long num3 = 200l;  
    System.out.println(num1 + num2);  //200
    System.out.println(num3 == (num1 + num2));  //true
    System.out.println(num3.equals(num1 + num2));  //false

    1、当一个基础数据类型与封装类进行==、+、-、*、/运算时,会将封装类进行拆箱,对基础数据类型进行运算。 
    2、对于num3.equals(num1 + num2)为false的原因很简单,我们还是根据代码实现来说明:

    @Override
    public boolean equals(Object o) {
         return (o instanceof Long) && (((Long) o).value == value);
    }

    它必须满足两个条件才为true: 
    1、类型相同 
    2、内容相同 
    上面返回false的原因就是类型不同。

    Integer num1 = 100;
    Ingeger num2 = 200;
    Long num3 = 300l;
    System.out.println(num3 == (num1 + num2)); //true

    可以看到运算的时候首先对num3进行拆箱(执行num3的longValue得到基础类型为long的值300),然后对num1和mum2进行拆箱(分别执行了num1和num2的intValue得到基础类型为int的值100和200),然后进行相关的基础运算。

    陷阱1:

    Integer integer100=null;  
    int int100=integer100;

    这两行代码是完全合法的,完全能够通过编译的,但是在运行时,就会抛出空指针异常。其中,integer100为Integer类型的对象,它当然可以指向null。但在第二行时,就会对integer100进行拆箱,也就是对一个null对象执行intValue()方法,当然会抛出空指针异常。所以,有拆箱操作时一定要特别注意封装类对象是否为null。

    总结: 
    1、需要知道什么时候会引发装箱和拆箱 
    2、装箱操作会创建对象,频繁的装箱操作会消耗许多内存,影响性能,所以可以避免装箱的时候应该尽量避免。

    3、equals(Object o) 因为原equals方法中的参数类型是封装类型,所传入的参数类型(a)是原始数据类型,所以会自动对其装箱,反之,会对其进行拆箱

    4、当两种不同类型用==比较时,包装器类的需要拆箱, 当同种类型用==比较时,会自动拆箱或者装箱

  • 相关阅读:
    SCAU 9504 面试
    SCAU 9503 懒人选座位
    SCAU 8628 相亲
    SCAU 10691 ACM 光环
    SCAU 8626 原子量计数
    SCAU 10674 等差对
    HDU ACM 1048 The Hardest Problem Ever (水题)
    SCAU 9502 ARDF
    SCAU 10686 DeathGod不知道的事情
    SCAU 8629 热身游戏(高精度)
  • 原文地址:https://www.cnblogs.com/newway644617704/p/15141267.html
Copyright © 2011-2022 走看看