概述

1、什么是自动拆装箱？

先说说什么是自动拆箱装箱吧？？

自动拆装箱在 Java5(就是Java1.5,后边改了命名) 中被引入，说白了，就是个语法糖。

自动装箱就是编译器自动将基础类型值转换成对应的包装类对象，比如将int的变量转换成Integer对象，这个过程叫做装箱；反之将Integer对象转换成int类型值，这个过程叫做拆箱。

2、基本类型与引用类型

​ 稍有 Java 基础的同学都应该知道 Java 的数据类型，大的分类就分为基础类型与引用类型。

​ 基础类型又能分为我们俗称的四类八种，分别为：

  • 四种整型：byte，short，int，long

他们的区别是所能存储的数据的长度不同，也就是说他们在内存中分配的内存长度不同

  • 两种浮点类型

32 位的单精度浮点 float，64位双精度浮点数double

  • 1种Unicode编码的字符单元 char
  • 最后就是boolean，真值布尔类型

​ 与我们今天主题相关的重点是：类中基础类型的成员是存储在栈内存中的，在对象创建的时候就会被初始化，无论你用或不用，他都会被赋予默认的初始值，比如 int 类型，就是 0。

​ 并且我们再扩展讨论一下这个情况：

​ int a = 1 int b = 1 System.out.printf(a == b) —- true

基本类型相同的值指向的是同一块内存区域，而 == 判断的是内存地址，也就是判断两者是否为同一个对象，所以返回的是 ture。

​ 注意：引用类型是否相等不能用 == 来判断，而是要用 equals()方法。

注意：引用类型是否相等不能用 == 来判断，而是要用 equals()方法。

引用类型分为类，接口，数组三种。之所以叫“引用类型”，是因为我们的引用类型的对象，是存在于堆内存中的，我们所持有的是栈内存中指向相应堆内存的一个引用。

这和自动拆装箱有什么关系？且看下文。

3、持有对象&包装类

在有些情况下，我们需要持有许多对象，也就是使用我们常用的集合类，然而集合类在设计的时候默认持有的数据类型是我们所有类型的单根超类 Object。

在将对象装入集合的时候，对象都会被向上转型为 Object，然后取出的时候，又通过参数化类型，也就是我们常用的泛型菱形语法，转型为我们装入的原始类型。

如果我们要持有的是基本类型呢？

基础类型的并没有父类，上面的操作不适合他们。于是 JDK 为每一个基础类型封装了相应的包装类：

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

​ 于是我们可以这样操作了

​ List intList = new ArrayList<>(); intList.add(1); //这里进行了自动装箱

注意后边一句，这就是我们说的自动装箱，因为 add() 方法需要传入的是 List 中所持有的参数化类型，也就是 int 的包装类型Integer，而我们传入的是一个 int 类型的值,这个 int 值被编译器自动包装成了 Integer 值,这个过程就是自动装箱。

你应该会想到，数组可以用来持有基本类型。但是有些时候我们要持有的数量是不确定的，数组在初始化的时候就必须确定长度，这使得数组来持有基本类型，或是对象都有很大的局限性。

集合持有对象是包装类的应用点。

包装类使基本类型有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。

自动拆装箱

​ 何为自动拆装箱，请看代码。

​ 在 Java5 以前要获取 Integer 的值需要这样写：

​ //装箱 Integer integer = new Integer(10); //拆箱 int i = integer.intValue();

而在 Java5 以后则简单多了：

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

可以看到在 Java5 之前，当你需要一个 Integer 类型的对象，你需要像其他对象一样，把他 new 出来(调用静态方法 Integer.valueOf(3) 来创建对象内部也是 new)；拆箱需要调用intValue() 方法来取出 int 值，而在 Java5 之后，你想创建 Integer 类型的对象，可以直接用 int 类型赋值，反过来 Integer 类型的也能赋值给 int 类型的变量。

简单地说：自动装/拆箱就是基本类型和他的包装类可以直接相互转换了。

自动拆装箱除了在赋值的时候编译器会自动进行，还有很多场景。

什么时候会发生自动拆装箱

1. 赋值

​ 上边大家已经看到了，不说啦。

2. 方法调用传入参数的时候

​ public void argAutoBoxing(Integer i) { } argAutoBoxing(1); //这里进行了自动装箱 public void argAutoUnBoxing(int i) { } argAutoUnBoxing(new Integer(1)); //这里进行了自动拆箱

3. 被操作符操作的时候

​ Integer integer = new Integer(1); int i = interger + 1 //会先拆箱成基本类型再进行运算

​ 一句话，就是编译器帮我们自动调用了拆装箱的方法，以 Integer 类型变成 int 类型为例子，自动装箱就是编译器自动调用了Integer.valueOf(int i) 方法；自动拆箱就是自动调用了Integer.intValue() 方法,其他基本类型类推。

​ 了解了自动装拆箱的概念，我们还需要注意的是，它会给我们带来什么问题？

自动装拆箱有哪些问题得注意？

​ \1. 性能问题

​ 在堆内存中创建对象的消耗肯定是要比使用栈内存要多的，同时在自动拆装箱的时候，也有一定的性能消耗，如果在数据量比较大，或者是循环的情况下，频繁的拆装箱并且生成包装类的时候，对性能的影响就是一星半点了，所以不是特殊的需求，例如上述被集合持有的情况，还是使用基本类型而不是包装类。

​ 举个例子：

​ Integer sum = 0; for(int i=1000; i<5000; i++){ sum+=i; }

上面的代码 sum+=i 可以看成 sum = sum + i，在 sum 被+操作符操作的时候，会对 sum 进行自动拆箱操作，进行数值相加操作，最后发生自动装箱操作转换成 Integer 对象。

​ 其内部变化和下面的代码一致：

​ sum = sum.intValue() + i; Integer sum = new Integer(result);

sum 为 Integer 类型，在上面的循环中会创建 4000 个无用的 Integer 对象，在这样庞大的循环中，会降低程序的性能并且加重了垃圾回收的工作量。

​ 因此在我们编程时，需要注意到这一点，正确地声明变量类型，避免因为自动装箱引起的性能问题。

​ 再举一个例子，在 Java 中的 HashMap 的性能也受到自动拆装箱的影响。

​ 因为 HashMap 默认接收的参数类型是HashMap ，所以在增删改查的时候，都会对 Key 值进行大量的自动拆装箱，为了解决这个问题，Java提供了 SparseArray，包括 SparseBoolMap, SparseIntMap, SparseLongMap, LongSparseMap。

​ 他们的 Key 值都是基本类型的值，例如 SparseIntMap 就是SparseIntMap,在避免了大量自动拆装箱的同时，还降低了内存消耗。

\2. 重载与自动装箱

​ 在 JDK5 之前，value(int i)和 value(Integer o) 是完全不相同的方法，开发者不会因为传入是 int 还是 Integer调用哪个方法困惑。

​ 但是由于自动装箱和拆箱的引入，处理重载方法时稍微有点复杂，例如在 ArrayList 中，有 remove(int index) 和remove(Object o) 两个重载方法，如果集合持有三个 Integer 类型值为 3,1,2 的对象，我们调用 remove(3), 是调用了 remove的哪个重载方法？

​ remove 掉的是值为 3 的对象，还是 remove 了 index 为3、值为 2 的那个对象呢？

​ 换句话说问题就是，参数 3 是否会被自动打包呢？

​ 答案是：不会！

​ 在这种情况下，编译器不会进行自动拆装箱，所以调用的是 remove(int index), index 为 3 值为 2 的这个 Integer对象会被 remove。

​ 通过以下例子我们可以验证：

​ public void testAutoBoxing(int i){ System.out.println(“primitive argument”); } public void testAutoBoxing(Integer integer){ System.out.println(“wrapper argument”); } //calling overloaded method int value = 1; test(value); //no autoboxing Integer iValue = value; test(iValue); //no autoboxing Output: primitive argument wrapper argument

\3. 缓存值问题

​ 这个问题是面试的常客了：

​ 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); } } Output: true false

为什么运行结果是这样呢，让我们来翻一翻源码：

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

欸，看来问题就出在 IntegerCache 类中了,我们再来翻一下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() {} }

​ 可以看到：在通过 valueOf 方法创建 Integer 对象的时候，如果数值在 [-128,127] 之间，便返回指向 IntegerCache.cache 中已经存在的对象的引用；否则创建一个新的 Integer 对象。

​ 上面的代码中 i1 和 i2 的数值为100，因此会直接从 cache 中取已经存在的对象，所以 i1 和 i2 指向的是同一个对象，而 i3 和 i4 超出了缓存值的范围，因此会创建两个不同的对象，引用自然不是一个地址了。

​ 看完上面，再来一道面试题看你会不会？

​ 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); } } Output: flase flase

至于为什么，小伙伴可以自己去看源码。

​ 这里要说的是，包装类都有相应的缓存机制，来降低一般情况下的资源消耗，但是每个包装类的机制肯定是不一样的，需要大家自己去探索。欢迎探索完留个言，加深你的印象。

​ \4. == 和 equals()

​ equals() 和 == 操作用于对象的比较，检查俩对象的相等性，但是他们俩的主要区别：在于前者是方法，后者是操作符。

​ 由于 Java 不支持操作符重载(overloading)，== 的行为对于每个对象来说与 equals() 是完全相同的，但是 equals() 可以基于业务规则的不同而重写（overridden )。

​ 另一个需要注意的不同点是 == 习惯用于原生（primitive）类型之间的比较，而 equals() 仅用于对象之间的比较。

​ == 与 equals的主要区别是：== 常用于比较原生类型，而 equals() 方法用于检查对象的相等性。

​ 另一个不同的点是：如果 == 和 equals() 用于比较对象，当两个引用地址相同，== 返回 true；而 equals() 返回 true 或者 false主要取决于重写实现。

​ 下边我们使用代码来说明在包装类和自动拆装箱时使用 == 和 equals() 的情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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);
        System.out.println(e==f);  //false 超过-128~127
        System.out.println(c==(a+b)); //true 拆箱
        System.out.println(c.equals(a+b)); //true
        System.out.println(g==(a+b));
        System.out.println(g.equals(a+b));
        System.out.println(g.equals(a+h));
    }
}

Output:
true
false
true
true
true
false
true

​ 这些运行结果你是否都答对了呢？

​ 在包装类的使用和自动拆装箱中，使用 == 运算符的时候，如果两个操作数都是包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（上边说到的的使用运算符触发了自动拆箱）。

​ 另外，对于包装器类型，equals() 方法并不会进行类型转换，和我们常见的对 String 类型使用一样，比较的是对象的值。

​ 理解了这个，大家应该就对结果清晰明了了，第一句和第二句是因为上边说过的缓存机制。

​ 重点解释一下第三句，a+b 包含了算术运算，因此会触发自动拆箱过程，因此它们比较的是数值是否相等。

​ 而对于 c.equals(a+b) 会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用 intValue（） 方法，得到了加法运算后的数值之后，便调用 Integer.valueOf 方法，再进行 equals 比较。

​ \5. 警惕 NullPointerException

​ 类中的基本类型的成员在声明的时候即使我们没有对变量进行赋值，编译器也会自动的为其赋予初始值，比如 int 值就是 0，boolean 类型的就是 false，所以我们在使用基本类型的时候，是不会出现NullPointerException 的。

​ 但在使用包装类的时候，我们就要注意这个问题了，不能因为有自动拆装箱这个语法糖，就忘记了包装类和基本类型的区别。

​ 如果你在使用包装类时没有通过显式、或是通过自动装箱机制为其赋值，在你取出值、或是通过自动拆箱使用该值的时候，就会发生 NullPointerException，这个是大家要注意的。

总结

​ 在日常开发中可能自动装拆箱在你不经意间就发生了，希望本篇文章有助于你全面理解自动拆装箱机制，同时可以规避常见的误区和风险。

​ 基础就是这样，不论你走的多远，都需要及时回顾、弥补，等工作中需要用到才补，会错失很多机会。