在 Java 中，基本数据类型（如 int、double）是“值类型”，不具备对象的特性（没有方法、不能参与面向对象编程）。而包装类（Wrapper Class） 正是为了解决这一问题，它将 8 种基本类型“包装”成对象，让基本类型能参与集合操作、泛型使用等场景。本文将带你全面掌握包装类的核心知识与实战技巧。

一、为什么需要包装类？核心作用解析

包装类的诞生，本质是为了打通“基本类型”与“面向对象编程”的壁垒，主要作用有 3 点：

1. 适配集合框架：Java 集合（如 ArrayList、HashMap）只能存储对象，无法直接存储基本类型，包装类让基本类型能“伪装”成对象存入集合。

◦ 示例：ArrayList<int> 是错误的，必须写成 ArrayList<Integer>。

2. 支持泛型：泛型参数只能是引用类型（对象），基本类型无法直接作为泛型参数，包装类是唯一解决方案。

◦ 示例：List<Double> 合法，List<double> 非法。

3. 提供丰富的工具方法：包装类内置了大量实用方法，如类型转换、数值比较、常量定义等，简化开发。

◦ 示例：Integer.parseInt("123") 将字符串转整数，Math.max() 本质依赖包装类的数值处理。

二、8种包装类全览：对应关系与分类

Java 为 8 种基本类型提供了一一对应的包装类，分为两大类别：

• 数值型包装类：继承自 Number 类，包含数值转换方法（如 intValue()、doubleValue()）。

• 非数值型包装类：Character 继承自 Object，Boolean 也继承自 Object，功能相对单一。

具体对应关系如下：
基本类型 包装类 所属类别 
byte Byte 数值型（Number） 
short Short 数值型（Number） 
int Integer 数值型（Number） 
long Long 数值型（Number） 
float Float 数值型（Number） 
double Double 数值型（Number） 
char Character 非数值型（Object） 
boolean Boolean 非数值型（Object） 

三、核心特性：自动装箱与自动拆箱

Java 5 引入的自动装箱（Autoboxing） 和自动拆箱（Unboxing），是包装类最常用的特性，它让基本类型与包装类之间的转换无需手动调用方法，极大简化了代码。

1. 自动装箱：基本类型 → 包装类

将基本类型的值直接赋值给对应的包装类变量，JVM 会自动创建包装类对象。
// 自动装箱：int → Integer
Integer num1 = 10; // 等价于 Integer num1 = Integer.valueOf(10);
// 自动装箱：double → Double
Double num2 = 3.14; // 等价于 Double num2 = Double.valueOf(3.14);
2. 自动拆箱：包装类 → 基本类型

将包装类对象直接赋值给对应的基本类型变量，JVM 会自动提取包装类中的基本值。
Integer num3 = 20;
// 自动拆箱：Integer → int
int value = num3; // 等价于 int value = num3.intValue();

Double num4 = 5.20;
// 自动拆箱：Double → double
double value2 = num4; // 等价于 double value2 = num4.doubleValue();
3. 注意事项：避免空指针异常

自动拆箱时，如果包装类对象为 null，会直接抛出 NullPointerException（空指针异常），这是开发中最常见的坑！
Integer num = null;
// 错误：num 为 null，拆箱时抛出空指针
int value = num; 
四、包装类的实用工具方法（高频考点）

各包装类都提供了大量静态方法，以下是开发中最常用的核心方法：

1. 类型转换方法

• 字符串转基本类型：parseXxx(String s)（Xxx 为基本类型，如 parseInt、parseDouble）
// 字符串转 int
int a = Integer.parseInt("123"); 
// 字符串转 double
double b = Double.parseDouble("3.14");
// 字符串转 boolean（仅"true"转true，其他全为false）
boolean c = Boolean.parseBoolean("false");
• 基本类型转字符串：String.valueOf(基本类型值) 或包装类的 toString() 方法
String s1 = String.valueOf(100); // "100"
String s2 = Integer.toString(200); // "200"
2. 数值比较与常量

• 比较两个包装类对象：推荐使用 compare() 方法，避免使用 ==（== 比较的是对象地址，而非值）
Integer x = 127;
Integer y = 127;
System.out.println(x == y); // true（127 在缓存范围内，地址相同）

Integer m = 128;
Integer n = 128;
System.out.println(m == n); // false（128 超出缓存范围，地址不同）
System.out.println(Integer.compare(m, n)); // 0（值相等，返回0）
• 常用常量：包装类定义了该类型的最大值、最小值，无需手动记忆
// int 类型的最大值和最小值
System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648
// double 类型的正无穷、负无穷
System.out.println(Double.POSITIVE_INFINITY); // Infinity
3. 字符判断（Character 特有）

Character 类提供了大量字符判断方法，用于处理字符类型数据：
char ch1 = 'A';
char ch2 = 'a';
char ch3 = '5';

// 判断是否为大写字母
System.out.println(Character.isUpperCase(ch1)); // true
// 判断是否为小写字母
System.out.println(Character.isLowerCase(ch2)); // true
// 判断是否为数字字符
System.out.println(Character.isDigit(ch3)); // true
// 转换为小写字母
System.out.println(Character.toLowerCase(ch1)); // 'a'
五、实战场景：包装类的典型用法

1. 集合中存储基本类型

集合只能存储对象，包装类是基本类型存入集合的唯一方式：
import java.util.ArrayList;
import java.util.List;

public class WrapperCollection {
    public static void main(String[] args) {
        // 正确：使用 Integer 包装类存储 int 值
        List<Integer> intList = new ArrayList<>();
        intList.add(10); // 自动装箱：10 → Integer
        intList.add(20);
        
        // 取值时自动拆箱：Integer → int
        int value = intList.get(0);
        System.out.println(value); // 10
    }
}
2. 泛型中使用包装类

泛型参数必须是引用类型，包装类是基本类型适配泛型的唯一选择：
// 正确：泛型参数使用 Integer（包装类）
public class GenericExample<T> {
    private T data;
    public T getData() { return data; }
    public void setData(T data) { this.data = data; }

    public static void main(String[] args) {
        // 泛型指定为 Integer，存储 int 类型的值
        GenericExample<Integer> example = new GenericExample<>();
        example.setData(100); // 自动装箱
        System.out.println(example.getData()); // 100
    }
}
六、常见误区与避坑指南

1. 不要用 == 比较包装类的值：== 比较对象地址，只有缓存范围内的数值（如 Integer 的 -128~127）才会复用对象，超出范围会新建对象，导致比较结果错误。推荐用 equals() 或 compare() 方法。
Integer a = 128;
Integer b = 128;
System.out.println(a.equals(b)); // true（比较值）
System.out.println(Integer.compare(a, b) == 0); // true（比较值）
2. 避免包装类对象为 null 时拆箱：自动拆箱前务必判断包装类是否为 null，否则会抛出空指针异常。
Integer num = null;
// 安全写法：先判断非空
if (num != null) {
    int value = num; // 拆箱安全
}
3. 注意 Boolean 的特殊性：Boolean 没有缓存，new Boolean(true) 与 Boolean.valueOf(true) 创建的对象地址不同，但 equals() 比较结果为 true。

七、总结

包装类是 Java 连接“基本类型”与“面向对象”的桥梁，核心掌握 3 点：

1. 对应关系：熟记 8 种基本类型与包装类的映射，尤其是 int→Integer、char→Character。

2. 核心特性：理解自动装箱/拆箱的原理，避开空指针和 == 比较的坑。

3. 实用方法：掌握 parseXxx()、compare()、Character 的字符判断等高频方法，结合集合、泛型场景灵活使用。

只要理清这些知识点，就能在开发中轻松驾驭包装类，避免常见错误，写出更规范的 Java 代码！