深入剖析Java中的装箱和拆箱

叁歲伎倆 2024-04-17 05:33 67阅读 0赞

### 一、关于拆箱和装箱 ###

**装箱** 就是自动将基本数据类型转换为包装器类型；**拆箱** 就是自动将包装器类型转换为基本数据类型

<table> 
 <thead> 
  <tr> 
   <th>基本数据类型</th> 
   <th>包装器类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int(4子节)</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>byte(1子节)</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short(2子节)</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>long(8子节)</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float(4子节)</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double(8子节)</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char(2子节)</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>boolean(未定)</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

具体是怎么进行装箱的呢？

如果需要生成一个数值的对象，那么只需要调用

Integer a = 100;    //装箱

这个过程就会根据数值创建对应的 Integer 对象这就是**装箱**

而拆箱呢，直接使用

int b = a;      //拆箱

这个时候就是**拆箱**

我们用一个例子来反编译一下，看看整个过程调用了那些方法

public class IntegerTest {
        public static void main(String[] args) {
            Integer a = 100;
            int b = a;
        }
    }

经过反编译

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzczODYz_size_16_color_FFFFFF_t_70][]

果不其然，都调用了各自包装类型的 valueOf(xxx) 方法和 xxxValue() 方法

因此可以总结一下：

**装箱过程就是通过包装器的 valueOf() 方法实现的，而拆箱过程是通过调用包装器的 xxxValue() 方法实现的**

### 二、关于 Integer.valueOf ###

由于 Integer 的这个方法蕴含着一些密码，因此我们拿源代码来分析一下

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

IntegerCache 的源码如下

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

通过源码可以看到，在 Interger 的 valueOf 方法中，如果数值在 \[-127, 128\] 范围的时候，就会去 IntegerCache.cache 这个数组寻找有没有存在的 Integer 对象的引用，如果有，则直接返回对象的引用，如果没有(超过了范围)，就新建一个 Integer 对象

这个是 cache 数组中已经存在的对象，只是一部分，数组下标范围为 \[0，255\]，对应数值范围是 \[-128，127\]

### 三、相关面试题 ###

**1.输出以下结果**

Integer a = 100;
    Integer b = 100;
    Integer a1 = 200;
    Integer b1 = 200;
    Integer a2 = new Integer(100);
    a == b;
    a1 == b1;
    a == a2;

结果： true、false、false

a 和 b 的数值为100的时候，因为 cache 数组中已经存在对象，因此可以直接取出；

a 和 b 的数值为200时，因为 cache 数组中没有相应的对象，因此只能 new 一个 Integer 对象，此时 a1 和 b1 分别指向不同的对象；

a 和 a2 比较的时候，由于 a 调用 valueOf() 进行自动装箱，而 a2 已经是 Integer 对象，相当于两个不同对象之间的比较，因为地址不同，所以肯定不等

需要注意的是，这整个过程中，都没有用到拆箱的过程，可以通过反编译进行验证

**2.输出以下代码运行的结果**

Double i1 = 100.0;
    Double i2 = 100.0;
    Double i3 = 200.0;
    Double i4 = 200.0;
    i1 == i2
    i3 == i4

结果：false、false。

为什么呢？由于 Double 在进行装箱的时候也会调用 valueOf() 这个方法，因此看一下源代码

public static Double valueOf(double d) {
        return new Double(d);
    }
    public Double(double value) {
        this.value = value;
    }

可以看到，Double 并没有 Integer 的冠军机制，而是直接返回了一个新的 Double 对象，因此以上的四个引用都是指向不同的对象的，所以不同

**为什么 Double 类的 valueOf() 方法会采用与 Integer 类的 valueOf() 方法不同的实现呢？**

很简单：在某个范围内的整型数值的个数是有限的，而浮点数却不是。

我又查看了其他几种数据类型的 valueOf 源码

其中，==Double 和 Float 没有缓存机制，都是直接返回新的对象== ；==Integer、Short、Byte、Character 有缓存机制==

**3.输出以下代码运行的结果**

Boolean b1 = false;
    Boolean b2 = false;
    Boolean b3 = true;
    Boolean b4 = true;
    b1 == b2
    b3 == b4
    b1 == b3

结果：true、true、false

为什么会这样呢？看一下 Boolean 的 valueOf() 的源代码

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

其中的 TRUE 和 FALSE，代表两个静态成员属性

public static final Boolean TRUE = new Boolean(true);
    public static final Boolean FALSE = new Boolean(false);

因此可以知道了，每次传入的 true 或 false，都是指向同一个 Boolean 对象，因此他们的引用肯定相同了

**4.输出以下代码运行的结果**

Integer a = 10;
    Integer b = 20;
    Integer c = 30;
    Integer d = 30;
    Integer e = 300;
    Integer f = 300;
    Integer g = a + b;
    c == d;
    e == f;
    c == g;
    c == (a + b);
    c.equals(a + b);

结果：true、false、true、true、true

先注意这句话：**当 "=="运算符的两个操作数都是 包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）**

前两个没什么好说的

**第三个**：由于运用了算术运算符(+)，因此右边的算式在进行计算之前会先调用 intVal() 方法进行**拆箱**，在进行相加，然后得到的结果30之后，由于前面是 Integer g，因此还会再调用 valueOf() 方法进行装箱。由于此时 cache() 数组中已经有了 30 了，因此直接指向缓存池中的 30 这个 Integer 对象。**此时 c == g 比较的还是对象的地址是否相同**

**第四个**：由于右边是 a+b，包含算术运算，因此会调用 intVal() 方法，将左边的 c 进行拆箱，之后又分别对 a 和 b 进行拆箱，即一共调用了三次拆箱过程，**最后比较的是数值大小，而不是地址**

**第五个**：equals() 方法会先除非自动拆箱，然后在触发自动装箱。a + b 的时候，会先调用两次 intVal() 进行拆箱，然后再调用 valueOf() 方法进行装箱，此时再用 equals() 方法比较。由于都是 Integer，且数值相等，则返回 true

**5.输出以下代码运行的结果**

Integer a = 10;
    Integer b = 20;
    Long g = 30L;
    Long h = 20L;
    g == (a + b);
    g.equals(a + b);
    g.equals(a + h);

结果：true、false、true

和上面一样，同样是使用拆箱，但是需要注意的是，Integer 类型调用 Integer.valueOf 进行拆箱，而 Long 类型调用 Long.valueOf 进行拆箱

最后一个结果是 true，因为 a + h 会使小的精度转为大的精度，最终的 30 是 Long 类型的，因此结果是 true

在 Java 5 中，为 Integer 的操作引入了一个新的特性，用来节省内存和提高性能。整型对象在内部实现中通过使用相同的对象引用实现了缓存和重用。

上面的规则适用于整数区间 -128 到 +127。

这种 Integer 缓存策略**仅在自动装箱（autoboxing）的时候有用**，使用构造器创建的 Integer 对象不能被缓存

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzczODYz_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/618a62f42aa645a7a70846e69a83f4ce.png