包装类型
包装类型把基本类型的值包成对象,这样它们才能放进泛型、集合,以及其他只接受引用类型的 API。不过,引用可能是 null,对象可能被缓存复用,表达式里还会自动发生类型转换。这些行为会让看起来差不多的代码得到不同的结果。例如两个 Integer 用 == 比较,值为 127 时结果保证是 true,值为 128 时就没有这个保证了。
1. 面试核心
先记住这几条,再读正文- 包装类型是引用类型,可以作为泛型参数,也可以用
null表示未提供的值。 - 自动拆箱会从包装对象中取出基本值。如果引用为
null,拆箱时就会抛出NullPointerException。卡 · 自动装箱与拆箱 Integer.valueOf保证缓存 -128 到 127 的对象。对这个范围内的相同值,返回的是相同引用。卡 · 包装对象缓存Integer.equals同时检查类型和数值。只有对方也是Integer,并且数值相同,才返回true。- 数值三元表达式根据分支类型决定是否拆箱。即使最终赋值给包装类型,也可能先拆箱,并因空值抛出异常。卡 · 三元表达式与重载选择
2. 基本类型与包装类型
包装类型是基本类型对应的类,它把一个基本值包成对象。需要它,是因为基本类型不是对象:泛型参数只能是引用类型,List<int> 无法通过编译,只能写成 List<Integer>。Java 为八种基本类型分别提供了对应的包装类:
| 基本类型 | 包装类型 |
|---|---|
boolean | Boolean |
byte | Byte |
short | Short |
char | Character |
int | Integer |
long | Long |
float | Float |
double | Double |
基本类型变量直接保存基本值,不能是 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?
数值必填并且只用于计算时,使用 int 更直接,也能避免空值拆箱。如果泛型、可空值或框架接口要求使用引用类型,就使用 Integer,并在计算前处理空值。
7.4 Integer 与 Long 能用 equals 比较数值吗?
不能用它判断这两种类型的数值是否相等。即使 Integer 与 Long 表示相同数值,equals 也会返回 false:
System.out.println(Integer.valueOf(1).equals(Long.valueOf(1))); // false
因为包装类的 equals 会同时检查类型和值。跨数值类型比较时,需要先转换为共同的表示,并确保转换不会丢失信息。
8. 面试题卡片
9. 参考资料
- Java Language Specification:Boxing Conversion
- Java Language Specification:Unboxing Conversion
- Java API:Integer
- Java API:Byte.valueOf
- Java API:Short.valueOf
- Java API:Long.valueOf
- Java API:Character.valueOf
- Java API:Boolean.valueOf
- Java API:Float.valueOf
- Java API:Double.valueOf
- OpenJDK 21:Integer 缓存与 AutoBoxCacheMax
- OpenJDK 21:Float.valueOf 实现
- OpenJDK 21:Double.valueOf 实现
- JLS:Conditional Operator
- JLS:Method Invocation
来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明