【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 泛型的规则与限制

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

// 泛型方法示例
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 时需规避。

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

泛型使用：
- 优先使用泛型类/方法，避免原始类型。
- 类型参数命名遵循 T、E 等约定，提高可读性。
包装类与缓存：
- 小整数（-128~127）直接赋值（利用缓存）。
- 比较包装类时始终用 equals()，避免 == 陷阱。
自动装箱拆箱：
- 避免在循环中高频使用，优先基本类型。
- 集合操作透明处理，无需显式转换。
字符串转换：
- 明确需求：基本类型用 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）