⛳ Java中的装箱和拆箱
Java中的装箱和拆箱目录
- ⛳ Java中的装箱和拆箱
-
- 一，为什么要进行装箱和拆箱
- 二，什么是装箱？什么是拆箱？
- 三，装箱和拆箱是如何实现的
- 四，面试中的相关问题
-
- 4.1，下面这段代码的输出结果是什么？
- 4.2,下面这段代码的输出结果是什么？
- 4.3，下面这段代码输出结果是什么：
- 4.4，谈谈Integer i = new Integer(xxx)和Integer i =xxx;这两种方式的区别。
- 4.5，下面程序的输出结果是什么？
- ⭐ 五，JVM内存结构中如何存储
⛳ Java中的装箱和拆箱
一，为什么要进行装箱和拆箱
在Java中，包装类是一种用于将基本数据类型封装成对象的机制。基本数据类型（如int、double、boolean等）是非对象类型，而包装类提供了一种将这些基本数据类型转换为对象的方式。Java中的包装类有以下几个主要的目的和用途：
- 提供对象化：基本数据类型是非对象类型，无法直接参与面向对象的操作。包装类通过将基本数据类型封装成对象，使得可以将其作为对象使用，并调用对象的方法。
- 提供类型转换：包装类提供了一系列方法，用于基本数据类型与其对应的包装类对象之间的相互转换。这种转换非常方便，可以在需要对象的场合使用基本数据类型，也可以在需要基本数据类型的场合使用对象。
- 提供集合的支持：Java的集合框架（如List、Set、Map等）只能存储对象，无法直接存储基本数据类型。包装类提供了与基本数据类型对应的对象形式，使得可以将基本数据类型作为对象存储在集合中。
- 提供与基本数据类型相关的工具方法：包装类提供了一些与基本数据类型相关的方法，如数值比较、数值转换、数值运算等，这些方法在处理基本数据类型时非常有用。
- 支持泛型：泛型是Java中的一种强类型机制，要求集合中的元素必须是对象类型。在需要使用基本数据类型的泛型集合时，可以通过包装类来实现。
综上所述，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 |
三，装箱和拆箱是如何实现的
以Integer类为例：
public class Main {
public static void main(String[] args) {
Integer i = 10;
int n = i;
}
}
反编译class文件之后得到如下内容：
从反编译得到的字节码内容可以看出，在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。
其他的也类似，比如Double、Character等。
因此可以用一句话总结装箱和拆箱的实现过程：
装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 xxxValue方法实现的。（xxx代表对应的基本数据类型）。
四，面试中的相关问题
下面列举一些常见的与装箱/拆箱有关的面试题。
4.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则是分别指向不同的对象。
4.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方法不同的实现。很简单：在某个范围内的整型数值的个数是有限的，而浮点数却不是。
Doublie 和 Float 的 valueOf() 方法：
// Double
public static Double valueOf(double d) {
return new Double(d);
}
// Float
public static Float valueOf(float f) {
return new Float(f);
}
两者都是返回一个新的实例对象。
注意，Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。
Double、Float的valueOf方法的实现是类似的。
4.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 Boolean object corresponding to the primitive
* value false.
*/
public static final Boolean FALSE = new Boolean(false);
至此，大家应该明白了为何上面输出的结果都是true了。
4.4，谈谈Integer i = new Integer(xxx)和Integer i =xxx;这两种方式的区别。
当然，这个题目属于比较宽泛类型的。但是要点一定要答上，我总结一下主要有以下这两点区别：
- 第一种方式不会触发自动装箱的过程；而第二种方式会触发；
- 在执行效率和资源占用上的区别。第二种方式的执行效率和资源占用在一般性情况下要优于第一种情况（注意这并不是绝对的）。
4.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方法并不会进行类型转换。
Long i7 = 10L;
Integer g = 10;
// 这样比较的是对象，会报错：java: 不可比较的类型: java.lang.Long和java.lang.Integer
System.out.println(i7 == g);
⭐ 五，JVM内存结构中如何存储
Integer、Short、Byte、Character、Long 这几个类在内存中都有自己的缓存区。我们以IntegerCache为例；
IntegerCache 在堆中的实现为：
public class Test03 {
public static void main(String[] args) {
Integer i1 = 127;
Integer i2 = 127;
Integer i3 = 128;
Integer i4 = 128;
System.out.println(i1 == i2); // true
System.out.println(i3 == i4); // false
}
}
