【Java】装箱（Boxing）与拆箱（Unboxing）

背景

基本数据类型

基本类型，或者叫做内置类型，是 Java 中不同于类（Class）的特殊类型。它们是我们编程中使用最频繁的类型。

Java 是一种强类型语言，第一次申明变量必须说明数据类型，第一次变量赋值称为变量的初始化。

Java 基本类型共有八种，基本类型可以分为三类：

• 字符类型 char
• 布尔类型 boolean
• 数值类型：
  • 整型：byte、short、int、long
  • 浮点型：float、double

Java 中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。

实际上，Java 中还存在另外一种基本类型 void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

基本数据类型有什么好处

我们都知道在 Java 语言中，new 一个对象是存储在堆里的，我们通过栈中的引用来使用这些对象；所以，对象本身来说是比较消耗资源的。

对于经常用到的类型，如 int 等，如果我们每次使用这种变量的时候都需要 new 一个 Java 对象的话，就会比较笨重。所以，和 C++ 一样，Java 提供了基本数据类型，这种数据的变量不需要使用 new 创建，他们不会在堆上创建，而是直接在栈内存中存储，因此会更加高效。

包装类（Wrapper Class）

Java 语言是一个面向对象的语言，但是 Java 中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类（Wrapper Class）。

包装类均位于 java.lang 包，包装类和基本数据类型的对应关系如下表所示

基本数据类型	包装类
byte	Byte
boolean	Boolean
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double

在这八个类名中，除了 Integer 和 Character 类以后，其它六个类的类名和基本数据类型一致，只是类名的第一个字母大写即可。

为什么需要包装类

很多人会有疑问，既然 Java 中为了提高效率，提供了八种基本数据类型，为什么还要提供包装类呢？

这个问题，其实前面已经有了答案，因为 Java 是一种面向对象语言，很多地方都需要使用对象而不是基本数据类型。比如，在集合类中，我们是无法将 int 、double 等类型放进去的。因为集合的容器要求元素是 Object 类型。

为了让基本类型也具有对象的特征，就出现了包装类型，它相当于将基本类型 “包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。

什么是装箱（Boxing）和拆箱（Unboxing）？

那么，有了基本数据类型和包装类，肯定有些时候要在他们之间进行转换。比如把一个基本数据类型的 int 转换成一个包装类型的 Integer 对象。

我们认为包装类是对基本类型的包装，所以，把基本数据类型转换成包装类的过程就是打包装，英文对应于 boxing，中文翻译为装箱。

反之，把包装类转换成基本数据类型的过程就是拆包装，英文对应于 unboxing，中文翻译为拆箱。

---

在 Java SE5 之前，如果要生成一个数值为 10 的 Integer 对象，必须这样进行：

Integer i = new Integer(10);

自动拆箱与自动装箱

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

Integer i = 10;

这个过程中会自动根据数值创建对应的 Integer 对象，这就是自动装箱（auto-boxing）。

那什么是自动拆箱（auto-unboxing）呢？顾名思义，跟装箱对应，就是自动将包装器类型转换为基本数据类型。

比如

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

简单一点说，

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

自动装箱和自动拆箱的实现原理

Interger 类的自动装箱 / 拆箱

我们以 Interger 类为例，下面看一段代码：

public class Main {
    public static void main(String[] args) {
        Integer i = 10;
        int n = i;
    }
}

对 .class 文件进行 javap 之后得到如下内容：

public class com.concretepage.lang.VolatileTest {
  public com.concretepage.lang.VolatileTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

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

从反编译得到的字节码内容可以看出，int 的自动装箱都是通过 Integer.valueOf() 方法来实现的，Integer 的自动拆箱都是通过 integer.intValue 来实现的。

对源代码进行反编译后，可以得到以下代码：

public static  void main(String[]args){
    Integer integer=Integer.valueOf(1); 
    int i=integer.intValue(); 
}

这也应证了我们上面的分析。

其他包装类的自动装箱 / 拆箱

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

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

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

哪些地方会自动拆 / 装箱

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

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

当表格中左边列出的基础类型与它们的包装类有如下几种情况时，编译器会自动帮我们进行装箱或拆箱：

• 进行 = 赋值操作（装箱或拆箱）
• 进行 +，-，*，/ 混合运算 （拆箱）
• 进行 >，<，== 比较运算（拆箱）
• 调用 equals 进行比较（装箱）
• 对 ArrayList，HashMap 等集合类的添加基础类型数据时（装箱）

场景一 将基本数据类型放入集合类

我们知道，Java 中的集合类只能接收对象类型，那么以下代码为什么会不报错呢？

List<Integer> li = new ArrayList<>();
for (int i = 1; i < 50; i ++){
    li.add(i);
}

将上面代码进行反编译，可以得到以下代码：

List<Integer> li = new ArrayList<>();
for (int i = 1; i < 50; i += 2){
    li.add(Integer.valueOf(i));
}

以上，我们可以得出结论，当我们把基本数据类型放入集合类中的时候，会进行自动装箱。

场景二 包装类型和基本类型的大小比较

有没有人想过，当我们对 Integer 对象与基本类型进行大小比较的时候，实际上比较的是什么内容呢？看以下代码：

Integer a=1;
System.out.println(a==1?"等于":"不等于");
Boolean bool=false;
System.out.println(bool?"真":"假");

对以上代码进行反编译，得到以下代码：

Integer a=1;
System.out.println(a.intValue()==1?"等于":"不等于");
Boolean bool=false;
System.out.println(bool.booleanValue?"真":"假");

可以看到，包装类与基本数据类型进行比较运算，是先将包装类进行拆箱成基本数据类型，然后进行比较的。

场景三 包装类型的运算

有没有人想过，当我们对 Integer 对象进行四则运算的时候，是如何进行的呢？看以下代码：

Integer i = 10;
Integer j = 20;
System.out.println(i+j);

反编译后代码如下：

Integer i = Integer.valueOf(10);
Integer j = Integer.valueOf(20);
System.out.println(i.intValue() + j.intValue());

我们发现，两个包装类型之间的运算，会被自动拆箱成基本类型进行。

场景四 三目运算符的使用

这是很多人不知道的一个场景，作者也是一次线上的血淋淋的 Bug 发生后才了解到的一种案例。看一个简单的三目运算符的代码：

boolean flag = true;
Integer i = 0;
int j = 1;
int k = flag ? i : j;

很多人不知道，其实在 int k = flag ? i : j; 这一行，会发生自动拆箱。反编译后代码如下：

boolean flag = true;
Integer i = Integer.valueOf(0);
int j = 1;
int k = flag ? i.intValue() : j;
System.out.println(k);

这其实是三目运算符的语法规范。当第二，第三位操作数分别为基本类型和对象时，其中的对象就会拆箱为基本类型进行操作。

因为例子中，flag ? i : j; 片段中，第二段的 i 是一个包装类型的对象，而第三段的 j 是一个基本类型，所以会对包装类进行自动拆箱。如果这个时候 i 的值为 null，那么久会发生 NullPointerException。

场景五、函数参数与返回值

这个比较容易理解，直接上代码了：

//自动拆箱
public int getNum1(Integer num) {
 return num;
}
//自动装箱
public Integer getNum2(int num) {
 return num;
}

缓存池

new Integer (123) 与 Integer.valueOf (123) 的区别在于：

• new Integer (123) 每次都会新建一个对象；
• Integer.valueOf (123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。

Integer x = new Integer(123);
Integer y = new Integer(123);
System.out.println(x == y);    // false
Integer z = Integer.valueOf(123);
Integer k = Integer.valueOf(123);
System.out.println(z == k);   // trueCopy to clipboardErrorCopied

valueOf () 方法的实现比较简单，就是先判断值是否在缓存池中，如果在的话就直接返回缓存池的内容。

自动拆装箱与缓存

Java SE 的自动拆装箱还提供了一个和缓存有关的功能，我们先来看以下代码，猜测一下输出结果：

public static void main(String... strings) {

    Integer integer1 = 3;
    Integer integer2 = 3;

    if (integer1 == integer2)
        System.out.println("integer1 == integer2");
    else
        System.out.println("integer1 != integer2");

    Integer integer3 = 300;
    Integer integer4 = 300;

    if (integer3 == integer4)
        System.out.println("integer3 == integer4");
    else
        System.out.println("integer3 != integer4");
}

我们普遍认为上面的两个判断的结果都是 false。虽然比较的值是相等的，但是由于比较的是对象，而对象的引用不一样，所以会认为两个 if 判断都是 false 的。在 Java 中，== 比较的是对象应用，而 equals 比较的是值。所以，在这个例子中，不同的对象有不同的引用，所以在进行比较的时候都将返回 false。奇怪的是，这里两个类似的 if 条件判断返回不同的布尔值。

上面这段代码真正的输出结果：

integer1 == integer2
integer3 != integer4

原因就和 Integer 中的缓存机制有关。在 Java 5 中，在 Integer 的操作上引入了一个新功能来节省内存和提高性能。整型对象通过使用相同的对象引用实现了缓存和重用：

• 适用于整数值区间 - 128 至 +127。
• 只适用于自动装箱。使用构造函数创建对象不适用。

我们只需要知道，当需要进行自动装箱时，如果数字在 - 128 至 127 之间时，会直接使用缓存中的对象，而不是重新创建一个对象。

其中的 javadoc 详细的说明了缓存支持 - 128 到 127 之间的自动装箱过程。最大值 127 可以通过 -XX:AutoBoxCacheMax=size 修改。

实际上这个功能在 Java 5 中引入的时候，范围是固定的 - 128 至 +127。后来在 Java 6 中，可以通过 java.lang.Integer.IntegerCache.high 设置最大值。

这使我们可以根据应用程序的实际情况灵活地调整来提高性能。到底是什么原因选择这个 - 128 到 127 范围呢？因为这个范围的数字是最被广泛使用的。 在程序中，第一次使用 Integer 的时候也需要一定的额外时间来初始化这个缓存。

面试中相关的问题

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

问题 1

下面这段代码的输出结果是什么？

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

事实上输出结果是：

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

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

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

注意，Integer、Short、Byte、Character、Long 这几个类的 valueOf 方法的实现是类似的。

Double、Float 的 valueOf 方法的实现是类似的。

问题 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);
    }
}s

输出结果是：

true
true

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

public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }
 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 - ”==“的含义

这是一个比较容易出错的地方，”==“可以用于字面量的比较，也可以用于对象的比较。

当用于字面量与字面量之间比较时，比较的是字面量值本身是否相等。

当用于字面量与对象之间比较时，会先将包装类对象进行自动拆箱（autounboxing）操作，此后比较的是字面量值本身是否相等。

而当用于对象与对象之间比较时，比较的不是对象代表的值，而是检查两个对象（在堆中）是否是同一对象，这个比较过程中没有自动装箱发生。

public class AutoboxingTest {

    public static void main(String args[]) {

        // Example 1: == comparison pure primitive – no autoboxing
        int i1 = 1;
        int i2 = 1;
        System.out.println("i1==i2 : " + (i1 == i2)); // true

        // Example 2: equality operator mixing object and primitive
        Integer num1 = 1; // autoboxing
        int num2 = 1;
        System.out.println("num1 == num2 : " + (num1 == num2)); // true

        // Example 3: special case - arises due to autoboxing in Java
        Integer obj1 = 1; // autoboxing will call Integer.valueOf()
        Integer obj2 = 1; // same call to Integer.valueOf() will return same
                            // cached Object

        System.out.println("obj1 == obj2 : " + (obj1 == obj2)); // true

        // Example 4: equality operator - pure object comparison
        Integer one = new Integer(1); // no autoboxing
        Integer anotherOne = new Integer(1);
        System.out.println("one == anotherOne : " + (one == anotherOne)); // false

    }
}

自动装 / 拆箱的性能问题

我们来看看 Integer i = new Integer (xxx) 和 Integer i =xxx; 这两种方式的区别：

• 第一种方式不会触发自动装箱的过程；而第二种方式会触发；
• 在执行效率和资源占用上的区别。第二种方式的执行效率和资源占用在一般性情况下要优于第一种情况（注意这并不是绝对的）。

例子

如果我告诉你：“只要修改一个字符，下面这段代码的运行速度就能提高 5 倍。”，你觉得可能么？

long t = System.currentTimeMillis();
Long sum = 0L;
for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;
}
System.out.println("total:" + sum);
System.out.println("processing time: " + (System.currentTimeMillis() - t) + " ms");

输出结果：

总数：2305843005992468481
处理时间：6756 ms

---

仔细琢磨一下，你可能会想到下面这种执行速度更快的实现方法：

long t = System.currentTimeMillis();
//Long sum = 0L;
long sum = 0L;
for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;
}
System.out.println("total:" + sum);
System.out.println("processing time: " + (System.currentTimeMillis() - t) + " ms") ;

输出结果：

总数：2305843005992468481
处理时间：1248 ms

分析

事实上，第一段代码段会自动转化为如下代码。所以，导致处理时间较长的原因也就水落石出了：不必要地创建了 2147483647 个”Long“类型实例。

long t = System.currentTimeMillis();
Long sum = 0L;
for (long i = 0; i < Integer.MAX_VALUE; i++) {
	sum += new Long(i);
}
System.out.println("total:" + sum);
System.out.println("processing time: " + (System.currentTimeMillis() - t) + " ms") ;

Reference

• 深入剖析 Java 中的装箱和拆箱 - https://www.cnblogs.com/dolphin0520/p/3780005.html
• Java 中的自动装箱与拆箱 - https://droidyue.com/blog/2015/04/07/autoboxing-and-autounboxing-in-java/
• 5 分钟彻底理解 - Java 自动装箱、拆箱 - https://juejin.im/post/5b5183e7e51d451912531cb5
• Java 性能要点：自动装箱 / 拆箱 (Autoboxing / Unboxing) - http://blog.oneapm.com/apm-tech/635.html
• 一文读懂什么是 Java 中的自动拆装箱 - https://juejin.im/post/5b8de48951882542d63b4662