【java笔记】泛型、包装类、自动装箱拆箱与缓存机制

一、泛型：类型安全的基石

1. 泛型的本质与原理

Java 泛型（Generics）是 JDK 5 引入的特性，通过类型参数化实现代码的通用性。泛型类、接口和方法允许在定义时声明类型参数（如 T、E、K、V），这些参数在使用时被具体类型替换。其核心原理是类型擦除（Type Erasure）：编译时泛型类型信息被擦除，替换为原始类型（如 Object），并插入必要的类型转换。运行时 JVM unaware 泛型，仅保留原始类型。

1.1 泛型的核心价值

• 类型安全：编译期检查类型匹配，避免运行时ClassCastException。
• 代码复用：通过参数化类型，一个类/接口/方法可处理多种数据类型。
• 消除强制转换：泛型自动推导类型，简化代码（如集合操作）。

// 非泛型时代的集合操作
List list = new ArrayList();
list.add("Hello");
String str = (String) list.get(0); // 强制转换

// 泛型时代
List<String> list = new ArrayList<>();
list.add("Hello");
String str = list.get(0); // 无需转换

// 泛型类示例
class Box<T> {
    private T value;
    public void set(T value) { this.value = value; }
    public T get() { return value; }
}

// 使用泛型
Box<String> stringBox = new Box<>();
stringBox.set("Java");
String str = stringBox.get(); // 无需强制类型转换

1.2 泛型擦除：运行时的类型透明

• 原理：编译后泛型类型被擦除，替换为原始类型（如T→Object，有界类型→上限类型）。
• 影响：
  • 运行时无法获取泛型具体类型（List<String>与List<Integer>运行时类型相同）。
  • 不支持基本类型（因擦除后无法区分int和Integer），必须使用包装类。

1.3 泛型的规则与限制

1. 类型参数仅支持引用类型：List<int>非法，需使用List<Integer>。
2. 通配符（Wildcards）：
   • <?>：未知类型（等效Object）。
   • <? extends T>：上界通配符（允许T及其子类）。
   • <? super T>：下界通配符（允许T及其父类）。
3. 多边界限制：<T extends ClassA & InterfaceB>（类在前，接口在后）。
4. 泛型方法：独立于类的类型参数，静态方法必须声明自己的泛型。

// 泛型方法示例
public static <T> void print(T element) {
    System.out.println(element.getClass());
}

// 通配符应用：遍历任意类型的集合
public static void printCollection(Collection<?> coll) {
    for (Object element : coll) {
        System.out.println(element);
    }
}

1.4 高级应用：泛型与设计模式

• 工厂模式：泛型工厂方法创建类型安全的实例。
• 策略模式：泛型接口定义通用算法（如Transformer<T, R>）。
• 容器类设计：实现通用数据结构（如Stack<T>、Queue<T>）。

// 泛型接口与实现
interface Transformer<T, R> {
    R transform(T input);
}

class UpperCaseTransformer implements Transformer<String, String> {
    public String transform(String input) {
        return input.toUpperCase();
    }
}

2. 泛型为何不支持基本数据类型？

• 擦除机制限制：基本类型（如 int）非对象，无法替换为 Object，而包装类（如 Integer）是引用类型，符合泛型要求。
• JVM 兼容性：JVM 字节码基于对象引用，基本类型需特殊指令处理，泛型支持基本类型会破坏兼容性。
• 结论：泛型中必须使用包装类，依赖自动装箱拆箱实现透明转换。

3. 泛型的优势

• 类型安全：编译期检查类型错误，避免运行时 ClassCastException。
• 代码复用：一套逻辑处理多种类型，减少冗余。
• 可读性提升：明确类型信息，无需强制转换。

二、包装类与自动装箱拆箱

1. 基本类型与包装类的映射

基本类型	包装类	缓存范围
byte	Byte	-128 ~ 127
short	Short	-128 ~ 127
int	Integer	-128 ~ 127（可配置）
long	Long	-128 ~ 127
char	Character	0 ~ 127
boolean	Boolean	TRUE/FALSE
float	Float	无缓存
double	Double	无缓存

2. 自动装箱（Autoboxing）与拆箱（Unboxing）

• 装箱：基本类型 → 包装类（编译器自动调用 valueOf()）。
• 拆箱：包装类 → 基本类型（编译器自动调用 xxxValue()）。

// 自动装箱
Integer numBoxed = 100; // 等价于 Integer.valueOf(100)

// 自动拆箱
int numUnboxed = numBoxed; // 等价于 numBoxed.intValue()

// 集合中的自动装箱
List<Integer> list = new ArrayList<>();
list.add(200); // 自动装箱为 Integer
int val = list.get(0); // 自动拆箱为 int

3. 装箱拆箱的性能考量

• 频繁操作（如循环中）可能引发性能损耗（对象创建/销毁）。
• 建议：对性能敏感场景（如大数据计算）优先使用基本类型。

三、Integer 缓存机制

1. 缓存原理

Integer 缓存 -128 到 127 范围内的对象（通过静态内部类 IntegerCache 实现）。调用 valueOf() 或自动装箱时：

• 范围内：返回缓存对象（共享引用）。
• 范围外：新建 Integer 对象（堆内存）。

Integer a = 100; // 缓存范围内，共享引用
Integer b = 100;
System.out.println(a == b); // true（引用相同）

Integer c = 200; // 范围外，新建对象
Integer d = 200;
System.out.println(c == d); // false（引用不同）

2. 缓存范围的扩展

通过 JVM 参数 -Djava.lang.Integer.IntegerCache.high=255 可扩大缓存上限（如 255），适用于高频使用较大整数的场景。

3. 比较陷阱：== vs equals()

• == 比较引用，缓存范围内为 true，否则为 false。
• equals() 比较值，始终正确。

Integer x = 127;
Integer y = 127;
System.out.println(x == y); // true（缓存内）

Integer m = 128;
Integer n = 128;
System.out.println(m == n); // false（缓存外）
System.out.println(m.equals(n)); // true（值相等）

四、字符串转数字：parseInt vs valueOf

方法	返回类型	缓存影响	异常处理
Integer.parseInt(s)	int（基本类型）	无（直接返回值）	抛出 NumberFormatException
Integer.valueOf(s)	Integer（对象）	缓存范围内返回缓存对象	同上

// parseInt：直接获取基本类型
int num1 = Integer.parseInt("123"); // 123

// valueOf：返回 Integer 对象（自动拆箱）
int num2 = Integer.valueOf("456"); // 自动拆箱为 int
Integer obj = Integer.valueOf("789"); // 保持包装类

// 基数转换（16 进制）
int hex = Integer.valueOf("FF", 16); // 255

最佳实践：

• 需基本类型时优先 parseInt（避免对象开销）。
• 需对象或利用缓存时用 valueOf（如频繁小整数场景）。

五、扩展知识：深入理解底层机制

1. 基本类型与包装类的存储位置

• 基本类型：局部变量存栈，成员变量存堆（对象属性）。
• 包装类：对象存堆，引用存栈。

2. 字符串常量池与对象创建

String s1 = "abc"; // 常量池存储
String s2 = new String("abc"); // 堆内存存储，常量池引用
System.out.println(s1 == s2); // false（引用不同）

3. 深浅拷贝与泛型限制

• 浅拷贝：复制引用，共享对象（如默认 clone()）。
• 深拷贝：递归复制对象，完全独立（需手动实现或序列化）。
• 泛型嵌套限制：受类型擦除影响，Java 不支持复杂嵌套泛型传递，设计 API 时需规避。

六、总结：最佳实践与编码规范

1. 泛型使用：

   • 优先使用泛型类/方法，避免原始类型。
   • 类型参数命名遵循 T、E 等约定，提高可读性。

2. 包装类与缓存：

   • 小整数（-128~127）直接赋值（利用缓存）。
   • 比较包装类时始终用 equals()，避免 == 陷阱。

3. 自动装箱拆箱：

   • 避免在循环中高频使用，优先基本类型。
   • 集合操作透明处理，无需显式转换。

4. 字符串转换：

   • 明确需求：基本类型用 parseInt，对象用 valueOf。
   • 处理异常：包裹 try-catch 处理非数字字符串。

七、代码示例汇总

// 泛型类
class GenericBox<T> {
    private T value;
    public void set(T value) { this.value = value; }
    public T get() { return value; }
}

// 自动装箱拆箱与缓存
Integer a = 100; // 缓存内
Integer b = Integer.valueOf(100); // 同上
int c = a + b; // 自动拆箱为 int，计算后装箱

// 字符串转换
try {
    int num = Integer.parseInt("123");
    Integer obj = Integer.valueOf("456");
} catch (NumberFormatException e) {
    System.err.println("Invalid number format: " + e.getMessage());
}

// 缓存扩展（JVM 参数：-Djava.lang.Integer.IntegerCache.high=255）
Integer x = 200;
Integer y = 200;
System.out.println(x == y); // true（若缓存上限调整为 255）

八、常见面试题解答

1. 为什么泛型不支持基本类型？
   答：泛型擦除后类型替换为 Object，基本类型非对象，无法赋值。需通过包装类实现。

2. Integer 缓存范围为何是 -128~127？
   答：JDK 设计团队认为该范围是日常高频使用的整数，缓存优化性能，超出范围创建新对象以节省内存。

3. 自动装箱拆箱的性能影响？
   答：单次操作影响可忽略，频繁操作（如循环）建议使用基本类型避免对象开销。

4. 如何比较两个 Integer 对象的值？
   答：使用 equals() 方法，避免 == 比较引用（缓存范围内除外）。

参考资料：

• Java 泛型官方文档
• Integer 源码解析
• JVM 类型擦除机制详解
• Java 基本数据类型 vs 包装类