跳到主要内容
约 9 分钟3 张卡

包装类型

包装类型把基本类型的值包成对象,这样它们才能放进泛型、集合,以及其他只接受引用类型的 API。不过,引用可能是 null,对象可能被缓存复用,表达式里还会自动发生类型转换。这些行为会让看起来差不多的代码得到不同的结果。例如两个 Integer 用 == 比较,值为 127 时结果保证是 true,值为 128 时就没有这个保证了。

1. 面试核心​

先记住这几条,再读正文
  • 包装类型是引用类型,可以作为泛型参数,也可以用 null 表示未提供的值。
  • 自动拆箱会从包装对象中取出基本值。如果引用为 null,拆箱时就会抛出 NullPointerException。卡 · 自动装箱与拆箱
  • Integer.valueOf 保证缓存 -128 到 127 的对象。对这个范围内的相同值,返回的是相同引用。卡 · 包装对象缓存
  • Integer.equals 同时检查类型和数值。只有对方也是 Integer,并且数值相同,才返回 true。
  • 数值三元表达式根据分支类型决定是否拆箱。即使最终赋值给包装类型,也可能先拆箱,并因空值抛出异常。卡 · 三元表达式与重载选择

2. 基本类型与包装类型​

包装类型是基本类型对应的类,它把一个基本值包成对象。需要它,是因为基本类型不是对象:泛型参数只能是引用类型,List<int> 无法通过编译,只能写成 List<Integer>。Java 为八种基本类型分别提供了对应的包装类:

基本类型包装类型
booleanBoolean
byteByte
shortShort
charCharacter
intInteger
longLong
floatFloat
doubleDouble

基本类型变量直接保存基本值,不能是 null;包装类型变量保存对象引用,可以是 null。除了表示这些值,包装类还提供解析、比较和进制转换等方法:

int port = Integer.parseInt("8080");
String hex = Integer.toHexString(255);
int compared = Integer.compare(10, 20);

Integer.parseInt 把 "8080" 解析为整数,所以 port 是 8080。hex 是 255 的十六进制表示 "ff",compared 则是负数,表示 10 小于 20。

所以整数集合要这样写:

List<Integer> numbers = List.of(1, 2, 3);

3. 自动装箱与拆箱​

装箱是把基本值包成包装对象,拆箱是从包装对象里取出基本值。基本值传给需要对象的地方,或者包装值参与基本类型的运算时,Java 会自动完成这两种转换:

// 自动转换
{
Integer boxed = 101; // 自动装箱
int value = boxed; // 自动拆箱
}

// 对照理解:显式取得包装对象与基本值
{
Integer boxed = Integer.valueOf(101);
int value = boxed.intValue();
}

下半段是对照写法:自动装箱相当于调用 Integer.valueOf(101),自动拆箱相当于调用 boxed.intValue()。除了赋值,方法调用、算术运算和条件表达式也会触发装箱或拆箱。

3.1 算术运算中的拆箱​

包装对象参与加减运算时,会先拆箱,再计算:

Integer count = 10;
int next = count + 1;

计算 count + 1 时,先把 count 拆箱为 int。计算结果是否需要重新装箱,则要看接收它的位置要求什么类型。

如果循环里有大量数值运算,又不需要表示空值,优先用基本类型。每次装箱都可能多处理一个对象,集合里保存包装元素,也比直接保存基本值多占内存。

3.2 null 拆箱​

包装类型的引用可以为 null,因此赋值、加法或条件判断都可能在拆箱时抛出异常:

Integer count = null;
// int value = count; // NullPointerException
// int next = count + 1; // NullPointerException

Boolean enabled = null;

// if (enabled) { // 自动拆箱,抛出 NullPointerException
// start();
// }

把 count 赋给 int、计算 count + 1,以及用 enabled 做条件判断,都需要先取出包装对象中的基本值。但这里的引用是 null,没有对象可供调用,所以这些操作都会在拆箱时抛出 NullPointerException。

如果业务要区分真、假和未提供三种情况,就需要明确处理 null。如果只有真和假两种情况,使用 boolean 可以从类型上排除空值。

4. 包装对象缓存​

包装类型是引用类型,两个包装变量用 == 比较,比较的是它们是否指向同一个对象,规则见 4.1 节。如果每次装箱都新建对象,两个 127 用 == 比较就会得到 false。实际上,Java 会缓存一部分包装对象,装箱时直接复用,减少重复创建。Java 语言规范保证,特定常量表达式装箱后会共享引用,其中整数常量的保证范围包括 -128 到 127:

// 保证范围内:127
{
Integer first = 127;
Integer second = 127;

System.out.println(first == second); // true
}

// 保证范围外:128
{
Integer first = 128;
Integer second = 128;

System.out.println(first == second); // 结果不应作为业务判断依据
System.out.println(first.equals(second)); // true
}

两次对 127 装箱,得到的是同一个对象,所以 == 返回 true。128 超出了保证范围,不能依赖 == 的结果判断数值是否相等,应使用 equals。

Integer.valueOf 也保证缓存 -128 到 127 的对象,而且允许实现扩展这个范围。因此,范围外的值是否共享引用,要看具体实现和配置。比较包装值时可以使用 equals,排序时使用 compare,也可以先处理空值,再拆箱比较。

其他包装类也有各自的缓存规则,需要区分 API 的保证与具体实现。下表比较的是接收基本类型参数的 valueOf 方法:

包装类Java 21 API 的缓存保证OpenJDK 17、21 的实现
Byte缓存全部 byte 值,即 -128 到 127缓存全部取值
Short、Long至少缓存 -128 到 127,允许缓存更多值缓存 -128 到 127
Integer至少缓存 -128 到 127,允许缓存更多值默认缓存 -128 到 127,上限可配置
Character至少缓存 0 到 127,允许缓存更多值缓存 0 到 127
Boolean根据参数返回 TRUE 或 FALSE复用这两个常量
Float、Double没有规定必须缓存的范围,也没有保证每次创建新对象不缓存,每次调用创建新对象

例如,在 OpenJDK 17、21 中,Double.valueOf(1.0) == Double.valueOf(1.0) 返回 false,因为两次调用得到的是不同对象。不过,这两个对象表示的数值仍然相同。

在 OpenJDK 17、21 的 HotSpot 中,设置 -XX:AutoBoxCacheMax=1000 可以把 Integer 的缓存上限扩展到 1000,下限仍然是 -128。这个参数只影响 Integer,不会扩大 Short、Long 或 Character 的缓存。它是具体实现的配置,业务代码不应依赖调整缓存后得到的引用比较结果。

4.1 == 比较​

要判断 == 比较的是什么,先看两侧表达式在编译时的类型,也就是静态类型。如果两侧都是包装类型引用,比较的是它们是否指向同一个对象:

Integer first = 1000;
Integer second = 1000;

System.out.println(first == second); // 不应期待为 true

// 一侧是基本类型时,先拆箱,再比较数值
Integer boxed = 1000;
int primitive = 1000;

System.out.println(boxed == primitive); // true

first == second 比较的是引用。boxed == primitive 的一侧是基本类型,会先把 boxed 拆箱,再比较数值,因此返回 true。如果 boxed 为 null,这一步拆箱就会抛出 NullPointerException。所以,同样写成 ==,两侧静态类型不同,比较的可能是对象身份,也可能是数值。

5. 使用场景​

下面三种情况需要用包装类型。

5.1 泛型与集合​

List<Integer>、Map<Long, User> 中的泛型参数都必须是引用类型。读写这类集合时,会隐式发生装箱和拆箱:

List<Integer> numbers = new ArrayList<>();
numbers.add(101); // 装箱
int first = numbers.get(0); // 拆箱

数据量大时,List<Integer> 里每个元素都是一个独立对象,内存开销明显高于 int[]。

5.2 缺失值语义​

包装类型可以用 null 表示未提供。例如,更新请求中的 Integer retryCount,可以区分没有传值和明确传入 0。

在进入核心计算之前,应先处理缺失值,避免让空值继续传入后续运算。具体怎么处理,取决于业务含义:

  • 缺失表示使用默认配置时,补上默认值。
  • 缺失有独立业务含义时,转换成明确的状态类型。
  • 参数为必填项时,直接报告校验错误。

5.3 框架和通用 API​

反射、对象关系映射(ORM)和序列化框架的部分接口,通过 Object 接收或返回数据,这时基本值也要用包装对象表示。

6. 三元表达式与重载选择​

三元表达式的结果类型由两个分支的类型决定,和等号左边是什么类型无关。所以即使把结果赋给 Integer,表达式内部也可能先拆箱,并因为空值抛出异常:

Integer missing = null;
boolean useMissing = true;
// Integer value = useMissing ? missing : 0; // NullPointerException
Integer value = useMissing ? missing : Integer.valueOf(0); // null

useMissing ? missing : 0 的结果类型是 int。选中 missing 后,需要先拆箱,但 missing 为 null,所以还没有赋给 Integer 变量就抛出了异常。第二种表达式的两个分支都是 Integer,会保留引用,因此得到 null。

重载选择也有先后顺序。编译器先找不需要装箱就能匹配的方法,例如允许把 int 拓宽成 long。只有这一阶段找不到适用的方法,才会考虑装箱:

static String choose(long value) { return "long"; }
static String choose(Integer value) { return "Integer"; }
// choose(1) 返回 "long":int 到 long 的拓宽先于装箱匹配。

7. 常见问题​

7.1 valueOf 与包装类构造器有什么区别?​

valueOf 可以复用缓存对象,显式调用构造器则会创建新对象。包装类构造器已经弃用,新代码应使用工厂方法、自动装箱或解析方法。

7.2 对包装值做加减会修改原对象吗?​

7.3 方法参数应该用 int 还是 Integer?​

7.4 Integer 与 Long 能用 equals 比较数值吗?​

8. 面试题卡片​

9. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明