解锁Java泛型：从包装类到类型安全的革命
在Java编程的旅程中，我们迟早会遇到一个强大的特性：泛型。它就像是给代码加上了“类型保险”，在编译阶段就能发现潜在的类型错误，极大地提升了程序的健壮性和可读性。今天，我们就以“能阅读Java集合源码”为目标，深入浅出地聊聊包装类和泛型。
一、包装类：基本数据类型的“外交官”
在面向对象的Java世界里，一切皆对象，但int、char、boolean等基本类型（primitive types）却是个例外——它们并非继承自Object。这带来了一个矛盾：当我们希望编写通用的、可处理多种数据的代码（比如集合类）时，这些基本类型却被排除在外了。
于是，包装类（Wrapper Classes）应运而生。Java为每一个基本类型都提供了一个对应的引用类型（类）。
基本数据类型 | 包装类 |
|---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
注意：除了
Integer和Character，其余包装类都是基本类型首字母大写。
有了包装类，基本类型就能以对象的身份参与泛型、集合等需要对象的场景了。
手动装箱与拆箱
最初，我们需要手动在基本类型和包装类之间转换：
int i = 10; // 装箱：基本类型 -> 包装类对象 Integer ii = Integer.valueOf(i); // 方式1：推荐（涉及缓存优化） Integer ij = new Integer(i); // 方式2：创建新对象 // 拆箱：包装类对象 -> 基本类型 int j = ii.intValue();自动装箱与拆箱
为了简化代码，Java引入了自动装箱（Autoboxing）和拆箱（Unboxing），编译器在幕后帮我们完成转换：
int i = 10; Integer ii = i; // 自动装箱，相当于 Integer.valueOf(i) int j = ii; // 自动拆箱，相当于 ii.intValue()一个有趣的面试题
自动装箱虽好，但也隐藏着细节。请问下面代码的输出是什么？
public static void main(String[] args) { Integer a = 127; Integer b = 127; Integer c = 128; Integer d = 128; System.out.println(a == b); // 输出什么？ System.out.println(c == d); // 输出什么？ }答案是：true 和 false。
这是因为Integer.valueOf()方法对-128到127范围内的整数做了缓存，在这个范围内返回的是同一个缓存对象（==比较地址，结果为true）。而超出此范围，则会创建新的对象，因此c和d是两个不同的对象，地址不同，结果为false。Character、Byte、Short、Long也有类似的缓存机制，Boolean则缓存了TRUE和FALSE两个对象。
二、泛型：类型的“参数化”
想象一下，你要实现一个能存储任意类型数据的数组容器。在没有泛型时，你可能会想到使用所有类的父类——Object。
class MyArray { public Object[] array = new Object[10]; public Object getPos(int pos) { return this.array[pos]; } public void setVal(int pos, Object val) { this.array[pos] = val; } }这样写，虽然能存任何数据，但取出时必须进行强制类型转换，这不仅繁琐，更危险的是，编译器无法在代码编写阶段发现类型转换错误，错误只能在运行时爆发，导致程序崩溃。
泛型正是为了解决这个问题而生的。通俗讲，泛型就是“类型的参数化”。你可以把类型像参数一样传递给类或方法，让编译器在编译期就进行严格的类型检查。
用泛型重写上面的“万能数组”：
// 这里的 <T> 是一个类型形参（Type Parameter），它是个占位符 class MyArray<T> { public T[] array = (T[])new Object[10]; // 注意这里有个问题，下文会讲 public T getPos(int pos) { return this.array[pos]; } // 返回T类型 public void setVal(int pos, T val) { this.array[pos] = val; } // 存入T类型 }使用泛型类：
MyArray<Integer> myArray = new MyArray<Integer>(); myArray.setVal(0, 10); // 正确，存入Integer // myArray.setVal(1, "hello"); // 编译错误！编译器会进行类型检查 Integer ret = myArray.getPos(0); // 正确，取出Integer，无需强制转换看，泛型带来了两大核心好处：
类型检查：在编译时阻止插入错误类型的对象。
类型转换：取出元素时自动转换，无需手动强转，代码更安全简洁。
三、深入泛型机制：擦除、上界与方法
1. 类型擦除（Type Erasure）
Java的泛型是“伪泛型”，它只在编译阶段有效。在编译后的字节码中，所有泛型信息（如<T>）都会被擦除，替换为它的上界（未指定时是Object）。这个过程叫做类型擦除。
所以，运行时MyArray<Integer>和MyArray<String>其实是同一个类——MyArray。这也是为什么我们不能直接new T[ ]的原因，因为运行时JVM不知道T具体是什么类型。
2. 泛型上界（Upper Bounds）
有时我们需要对泛型的类型参数加以限制。比如，只希望接收数字类型。这时可以使用上界。
// E 只能是 Number 或其子类 (如 Integer, Double) public class MyArray<E extends Number> { /* ... */ } MyArray<Integer> list1 = new MyArray<>(); // OK // MyArray<String> list2 = new MyArray<>(); // 编译错误！String不是Number子类上界也可以是接口，要求类型参数必须实现某个接口：
// E 必须实现了 Comparable 接口，以便能比较大小 public class MyArray<E extends Comparable<E>> { /* ... */ }3. 泛型方法
不仅类可以泛型化，方法也可以。泛型方法可以在普通类中定义。
public class Util { // 定义一个可以交换任意类型数组两个元素的静态泛型方法 public static <T> void swap(T[] array, int i, int j) { T temp = array[i]; array[i] = array[j]; array[j] = temp; } } // 使用 Integer[] a = {1, 2, 3}; Util.swap(a, 0, 2); // 编译器会自动推导出T是Integer // 也可以显式指定 Util.<Integer>swap(a, 0, 2);四、泛型使用的注意事项与最佳实践
泛型不接受基本类型：正如开头所述，泛型的类型参数必须是类。所以要用
List<Integer>，而不是List<int>。这正是包装类存在的重要价值之一。谨慎使用裸类型：像
MyArray list = new MyArray()这样不带类型参数的用法称为裸类型（Raw Type）。它只是为了兼容老代码而保留的，会失去所有泛型的安全检查，不应在新代码中使用。理解类型擦除的影响：由于擦除机制，
instanceof T、new T()、T.class等操作都是非法的。创建泛型数组通常也需要通过反射等复杂方式实现。
总结
泛型是Java迈向更强类型安全、更高代码复用性的一大步。从包装类解决基本类型的“对象化”问题，到泛型实现类型的参数化，它们共同构建了Java集合框架等强大功能的基石。理解泛型，尤其是其背后的擦除机制，是阅读ArrayList、HashMap等源码，乃至编写高质量、可复用Java代码的关键一步。下次当你使用List<String>时，不妨想一想，这简洁声明的背后，是编译器在为你默默筑起一道坚固的类型安全防线。