Java 泛型详解

二、泛型类

2.1 基本语法

// 单个类型参数
class GenericClass<T> {
    private T data;
    public GenericClass(T data) {
        this.data = data;
    }
    public T getData() {
        return data;
    }
}
// 多个类型参数
class Pair<K, V> {
    private K key;
    private V value;
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
    public K getKey() {
        return key;
    }
    public V getValue() {
        return value;
    }
}

2.2 常用类型参数命名

2.3 实战示例：元组类

// 二元组
public class Tuple2<A, B> {
    public final A first;
    public final B second;
    public Tuple2(A first, B second) {
        this.first = first;
        this.second = second;
    }
    @Override
    public String toString() {
        return "(" + first + ", " + second + ")";
    }
}
// 三元组
public class Tuple3<A, B, C> extends Tuple2<A, B> {
    public final C third;
    public Tuple3(A first, B second, C third) {
        super(first, second);
        this.third = third;
    }
    @Override
    public String toString() {
        return "(" + first + ", " + second + ", " + third + ")";
    }
}
// 使用示例
public class TupleExample {
    public static void main(String[] args) {
        // 返回多个值
        Tuple2<String, Integer> person = new Tuple2<>("张三", 25);
        System.out.println(person); // (张三，25)
        // 不同类型组合
        Tuple3<String, Integer, Boolean> data = new Tuple3<>("Java", 95, true);
        System.out.println(data); // (Java, 95, true)
    }
}

三、泛型方法

3.1 基本语法

泛型方法的类型参数放在返回值之前：

public class GenericMethod {
    // 泛型方法
    public <T> void print(T item) {
        System.out.println(item.getClass().getName() + ": " + item);
    }
    // 多个类型参数
    public <K, V> void printPair(K key, V value) {
        System.out.println(key + " = " + value);
    }
    // 返回泛型类型
    public <T> T getFirst(T[] array) {
        return array.length > 0 ? array[0] : null;
    }
}

3.2 类型推断

public class TypeInference {
    public static <T> T identity(T item) {
        return item;
    }
    public static void main(String[] args) {
        // 显式指定类型
        String s1 = GenericMethod.<String>identity("Hello");
        // 类型推断（推荐）
        String s2 = identity("Hello");
        // 编译器自动推断为 String
        Integer i = identity(123); // 自动推断为 Integer
    }
}

3.3 实战示例：通用工具方法

import java.util.*;
import java.util.function.Function;

public class GenericUtils {
    // 交换数组元素
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    // 查找最大值
    public static <T extends Comparable<T>> T max(T[] array) {
        if (array == null || array.length == 0) {
            return null;
        }
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }

    // 转换 List
    public static <T, R> List<R> map(List<T> list, Function<T, R> mapper) {
        List<R> result = new ArrayList<>();
        for (T item : list) {
            result.add(mapper.apply(item));
        }
        return result;
    }

    public static void main(String[] args) {
        // 交换示例
        String[] names = {"Alice", "Bob", "Charlie"};
        swap(names, 0, 2);
        System.out.println(Arrays.toString(names)); // [Charlie, Bob, Alice]
        // 查找最大值
        Integer[] numbers = {3, 7, 2, 9, 1};
        System.out.println("最大值：" + max(numbers)); // 9
        // 转换 List
        List<String> words = Arrays.asList("hello", "world");
        List<Integer> lengths = map(words, String::length);
        System.out.println(lengths); // [5, 5]
    }
}

四、类型擦除

4.1 什么是类型擦除

Java 泛型采用**类型擦除（Type Erasure）**机制实现，这是 Java 泛型与 C++ 模板的本质区别。编译器在编译时检查类型安全，但在生成字节码时会擦除所有泛型类型信息。

擦除规则：

• 无边界类型参数（<T>）→ 擦除为 Object
• 有边界类型参数（<T extends Number>）→ 擦除为第一个边界类型 Number
• List<String> 和 List<Integer> → 运行时都是原始类型 List
• 编译器会自动插入类型转换代码，保证类型安全

import java.util.*;

public class ErasureExample {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        // 运行时类型相同
        System.out.println(list1.getClass() == list2.getClass()); // true
        System.out.println(list1.getClass()); // class java.util.ArrayList
        // 泛型信息在运行时不存在
        System.out.println(list1.getClass().getTypeParameters().length); // 1
        System.out.println(list1.getClass().getTypeParameters()[0].getName()); // E
    }
}

4.2 擦除的影响

类型擦除带来的限制：

❌ 限制 1：无法创建泛型数组

class Container<T> {
    // ❌ 编译错误：Cannot create a generic array of T
    // private T[] array = new T[10];
}

❌ 限制 2：无法使用 instanceof 检查泛型类型

class Container<T> {
    // ❌ 编译错误：Cannot perform instanceof check against type parameter T
    // public boolean check(Object obj) {
    //     return obj instanceof T;
    // }
}

❌ 限制 3：无法创建泛型类型实例

class Container<T> {
    // ❌ 编译错误：Cannot instantiate the type T
    // public T create() {
    //     return new T();
    // }
}

❌ 限制 4：静态字段不能使用类型参数

class Container<T> {
    // ❌ 编译错误：Cannot make a static reference to the non-static type T
    // private static T staticItem;
}

✅ 解决方案：传递 Class 对象

通过传递 Class<T> 对象，可以在运行时获取类型信息：

import java.lang.reflect.Array;

class Container<T> {
    private Class<T> type;
    public Container(Class<T> type) {
        this.type = type;
    }
    // ✅ 使用反射创建数组
    @SuppressWarnings("unchecked")
    public T[] createArray(int size) {
        return (T[]) Array.newInstance(type, size);
    }
    // ✅ 使用 Class.isInstance() 检查类型
    public boolean check(Object obj) {
        return type.isInstance(obj);
    }
    // ✅ 使用反射创建实例
    public T create() throws Exception {
        return type.getDeclaredConstructor().newInstance();
    }
}
// 使用示例
Container<String> container = new Container<>(String.class);
String[] array = container.createArray(5);
System.out.println(container.check("Hello")); // true
System.out.println(container.check(123)); // false
String instance = container.create(); // 创建新的 String 实例

4.3 边界与擦除的关系

类型参数的边界决定了擦除后的类型：

// 示例 1：无边界 → 擦除为 Object
class Box<T> {
    private T item; // 擦除后：private Object item;
    public void set(T item) {
        this.item = item;
    }
    // 擦除后：public void set(Object item) { ... }
}

// 示例 2：单个边界 → 擦除为边界类型
class NumberBox<T extends Number> {
    private T item; // 擦除后：private Number item;
    public void process() {
        // ✅ 可以调用 Number 的方法
        double value = item.doubleValue();
        int intValue = item.intValue();
    }
}

// 示例 3：多个边界 → 擦除为第一个边界
interface Readable {
    String read();
}
interface Writable {
    void write(String data);
}
class DataBox<T extends Number & Readable & Writable> {
    private T item; // 擦除后：private Number item
    // 注意：第一个边界必须是类（如果有类的话），接口放在后面
    public void process() {
        // ✅ 可以调用 Number 的方法
        item.doubleValue();
        // ✅ 也可以调用接口方法（编译器会插入强制转换）
        item.read();
        item.write("data");
    }
}

重要规则：

• 多个边界时，类必须放在第一位
• 正确：<T extends Number & Serializable>
• 错误：<T extends Serializable & Number>（编译错误）

五、边界与通配符

5.1 类型参数边界（extends）

使用 extends 关键字限制类型参数的范围，使其必须是某个类的子类或实现某个接口。

// 上界：T 必须是 Number 或其子类
class NumberProcessor<T extends Number> {
    private T number;
    public NumberProcessor(T number) {
        this.number = number;
    }
    public double getDoubleValue() {
        return number.doubleValue(); // 可以调用 Number 的方法
    }
    public int compare(T other) {
        return Double.compare(number.doubleValue(), other.doubleValue());
    }
}
// 使用示例
NumberProcessor<Integer> p1 = new NumberProcessor<>(100);
NumberProcessor<Double> p2 = new NumberProcessor<>(3.14);
System.out.println(p1.getDoubleValue()); // 100.0
System.out.println(p2.compare(2.5)); // 1
// ❌ 编译错误：String 不是 Number 的子类
// NumberProcessor<String> p3 = new NumberProcessor<>("error");

5.2 通配符详解

通配符（Wildcard）用于表示未知类型，主要用于方法参数，提供更灵活的类型匹配。

PECS 原则：Producer Extends, Consumer Super

• 如果你需要从集合中读取数据（生产者），使用 <? extends T>
• 如果你需要向集合中写入数据（消费者），使用 <? super T>
• 如果既要读又要写，不要使用通配符

import java.util.*;

public class WildcardExample {
    // 示例 1：使用 extends 读取数据（生产者）
    public static double sum(List<? extends Number> list) {
        double total = 0;
        for (Number num : list) {
            total += num.doubleValue(); // ✅ 可以读取为 Number
        }
        // list.add(1); // ❌ 编译错误：不能写入
        return total;
    }

    // 示例 2：使用 super 写入数据（消费者）
    public static void addNumbers(List<? super Integer> list) {
        list.add(1); // ✅ 可以写入 Integer
        list.add(2);
        list.add(3);
        // Integer num = list.get(0); // ❌ 编译错误：只能读取为 Object
        Object obj = list.get(0); // ✅ 可以读取为 Object
    }

    // 示例 3：无界通配符
    public static void printList(List<?> list) {
        for (Object obj : list) {
            // ✅ 只能读取为 Object
            System.out.println(obj);
        }
        // list.add("test"); // ❌ 编译错误：不能写入（null 除外）
        list.add(null); // ✅ 可以写入 null
    }

    public static void main(String[] args) {
        // extends 示例：可以接受 Number 的任何子类
        List<Integer> integers = Arrays.asList(1, 2, 3);
        List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
        System.out.println("整数求和：" + sum(integers)); // 6.0
        System.out.println("浮点数求和：" + sum(doubles)); // 6.6

        // super 示例：可以接受 Integer 的任何父类
        List<Number> numbers = new ArrayList<>();
        List<Object> objects = new ArrayList<>();
        addNumbers(numbers); // ✅ Number 是 Integer 的父类
        addNumbers(objects); // ✅ Object 是 Integer 的父类
        System.out.println("numbers: " + numbers); // [1, 2, 3]
        System.out.println("objects: " + objects); // [1, 2, 3]

        // 无界通配符示例
        printList(integers);
        printList(Arrays.asList("A", "B", "C"));
    }
}

5.3 多重边界

一个类型参数可以有多个边界，用 & 连接。类型必须同时满足所有边界条件。

interface Flyable {
    void fly();
}
interface Swimmable {
    void swim();
}
// 多重边界：T 必须同时实现 Flyable 和 Swimmable
class Animal<T extends Flyable & Swimmable> {
    private T creature;
    public Animal(T creature) {
        this.creature = creature;
    }
    public void move() {
        creature.fly(); // ✅ 可以调用 Flyable 的方法
        creature.swim(); // ✅ 可以调用 Swimmable 的方法
    }
}
// 实现类必须同时实现两个接口
class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("鸭子飞行");
    }
    @Override
    public void swim() {
        System.out.println("鸭子游泳");
    }
}
class Fish implements Swimmable {
    @Override
    public void swim() {
        System.out.println("鱼游泳");
    }
}
// 使用示例
Animal<Duck> duck = new Animal<>(new Duck());
duck.move(); // 输出：鸭子飞行 \n 鸭子游泳
// ❌ 编译错误：Fish 只实现了 Swimmable，没有实现 Flyable
// Animal<Fish> fish = new Animal<>(new Fish());

多重边界的规则：

1. 最多只能有一个类边界，且必须放在第一位
2. 可以有多个接口边界
3. 格式：<T extends 类 & 接口 1 & 接口 2 & ...>

// ✅ 正确：类在前，接口在后
class Example<T extends Number & Comparable<T> & Serializable> {}
// ❌ 错误：接口不能放在类前面
// class Example<T extends Comparable<T> & Number> {}
// ❌ 错误：不能有多个类边界
// class Example<T extends Number & Integer> {}

六、常见问题与陷阱

6.1 基本类型不能作为类型参数

Java 泛型不支持基本类型（primitive types），必须使用对应的包装类。

// ❌ 错误：不能使用基本类型
// List<int> list = new ArrayList<>();
// Map<double, boolean> map = new HashMap<>();

// ✅ 正确：使用包装类
List<Integer> list = new ArrayList<>();
Map<Double, Boolean> map = new HashMap<>();
// 自动装箱和拆箱
list.add(1); // 自动装箱：int → Integer
int value = list.get(0); // 自动拆箱：Integer → int

// 注意：频繁装箱拆箱会影响性能
List<Integer> numbers = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
    numbers.add(i); // 每次循环都会装箱，性能开销
}

性能优化建议：

• 对于大量基本类型数据，考虑使用数组 int[] 而不是 List<Integer>
• 或使用第三方库如 Trove、FastUtil 提供的基本类型集合

6.2 不能实现同一泛型接口的不同变体

由于类型擦除，一个类不能同时实现同一个泛型接口的不同参数化版本。

interface Processor<T> {
    void process(T item);
}

// ✅ 正确：实现单一类型
class StringProcessor implements Processor<String> {
    @Override
    public void process(String item) {
        System.out.println("处理字符串：" + item);
    }
}

// ❌ 错误：不能同时实现 Processor<String> 和 Processor<Integer>
// 因为类型擦除后，两个接口都变成了 Processor，方法签名冲突
// class MultiProcessor implements Processor<String>, Processor<Integer> {
//     @Override
//     public void process(String item) { } // 擦除后：process(Object)
//     @Override
//     public void process(Integer item) { } // 擦除后：process(Object) - 冲突！
// }

// ✅ 解决方案：使用不同的方法名或包装类
class MultiProcessor {
    public void processString(String item) {
        System.out.println("处理字符串：" + item);
    }
    public void processInteger(Integer item) {
        System.out.println("处理整数：" + item);
    }
}

6.3 不能创建泛型数组

由于类型擦除，Java 不允许直接创建泛型数组。

import java.lang.reflect.Array;
import java.util.*;

// ❌ 错误：不能创建泛型数组
// T[] array = new T[10];
// List<String>[] lists = new ArrayList<String>[10]; // 编译错误
// List<Integer>[] intLists = new List<Integer>[5]; // 编译错误

// ✅ 解决方案 1：使用 ArrayList 代替数组
List<List<String>> lists = new ArrayList<>();
lists.add(new ArrayList<>());
lists.add(new ArrayList<>());

// ✅ 解决方案 2：使用原始类型数组（会有警告）
@SuppressWarnings("unchecked")
List<String>[] lists2 = (List<String>[]) new List[10];
for (int i = 0; i < lists2.length; i++) {
    lists2[i] = new ArrayList<>();
}

// ✅ 解决方案 3：使用 Array.newInstance()（需要 Class 对象）
class GenericArray<T> {
    private T[] array;
    @SuppressWarnings("unchecked")
    public GenericArray(Class<T> type, int size) {
        array = (T[]) Array.newInstance(type, size);
    }
    public void set(int index, T value) {
        array[index] = value;
    }
    public T get(int index) {
        return array[index];
    }
}
// 使用示例
GenericArray<String> stringArray = new GenericArray<>(String.class, 10);
stringArray.set(0, "Hello");
System.out.println(stringArray.get(0)); // Hello

为什么不能创建泛型数组？

• 数组在运行时需要知道元素的确切类型（用于类型检查）
• 泛型类型在运行时被擦除，无法提供这个信息
• 如果允许创建泛型数组，会破坏类型安全

6.4 泛型方法重载问题

由于类型擦除，某些看似合理的方法重载实际上会导致编译错误。

import java.util.*;

// ❌ 错误：擦除后方法签名相同
// class Overload {
//     void method(List<String> list) { }
//     void method(List<Integer> list) { }
// }

// ✅ 解决方案 1：使用不同的方法名
class Overload {
    void processStrings(List<String> list) {
        for (String s : list) {
            System.out.println("字符串：" + s);
        }
    }
    void processIntegers(List<Integer> list) {
        for (Integer i : list) {
            System.out.println("整数：" + i);
        }
    }
}

// ✅ 解决方案 2：使用泛型方法
class GenericOverload {
    <T> void process(List<T> list, Class<T> type) {
        System.out.println("处理类型：" + type.getSimpleName());
        for (T item : list) {
            System.out.println(item);
        }
    }
}
// 使用示例
GenericOverload processor = new GenericOverload();
processor.process(Arrays.asList("A", "B"), String.class);
processor.process(Arrays.asList(1, 2, 3), Integer.class);

6.5 原始类型的危险

使用原始类型（Raw Type）会绕过泛型的类型检查，导致运行时错误。

import java.util.*;

// ❌ 危险：使用原始类型
List rawList = new ArrayList(); // 原始类型，没有类型参数
rawList.add("String");
rawList.add(123);
rawList.add(new Object());
// 运行时错误！
String s = (String) rawList.get(1); // ClassCastException

// ✅ 正确：始终使用泛型
List<String> stringList = new ArrayList<>();
stringList.add("String");
// stringList.add(123); // 编译错误，类型安全

// ⚠️ 警告：原始类型与泛型混用
List<String> genericList = new ArrayList<>();
List rawList2 = genericList; // 警告：unchecked conversion
rawList2.add(123); // 编译通过，但破坏了类型安全
String str = genericList.get(0); // 可能导致 ClassCastException

最佳实践：

• 永远不要使用原始类型（除非与遗留代码交互）
• 如果不确定类型，使用 List<?> 而不是 List
• 使用 @SuppressWarnings("unchecked") 时要格外小心

七、实战示例

7.1 泛型栈

import java.util.*;

public class GenericStack<T> {
    private List<T> items = new ArrayList<>();

    public void push(T item) {
        items.add(item);
    }

    public T pop() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        return items.remove(items.size() - 1);
    }

    public T peek() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        return items.get(items.size() - 1);
    }

    public boolean isEmpty() {
        return items.isEmpty();
    }

    public int size() {
        return items.size();
    }
}
// 使用
GenericStack<String> stack = new GenericStack<>();
stack.push("A");
stack.push("B");
System.out.println(stack.pop()); // B

7.2 泛型缓存

import java.util.*;

public class Cache<K, V> {
    private Map<K, V> cache = new HashMap<>();
    private int maxSize;

    public Cache(int maxSize) {
        this.maxSize = maxSize;
    }

    public void put(K key, V value) {
        if (cache.size() >= maxSize) {
            // 简单的 LRU：删除第一个
            K firstKey = cache.keySet().iterator().next();
            cache.remove(firstKey);
        }
        cache.put(key, value);
    }

    public V get(K key) {
        return cache.get(key);
    }

    public boolean containsKey(K key) {
        return cache.containsKey(key);
    }
}
// 使用
Cache<String, User> userCache = new Cache<>(100);
userCache.put("user1", new User("张三"));
User user = userCache.get("user1");

7.3 泛型构建器

import java.util.function.BiConsumer;

public class Builder<T> {
    private T object;

    public Builder(Class<T> clazz) throws Exception {
        object = clazz.getDeclaredConstructor().newInstance();
    }

    public <V> Builder<T> set(BiConsumer<T, V> setter, V value) {
        setter.accept(object, value);
        return this;
    }

    public T build() {
        return object;
    }
}
// 使用
class Person {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
Person person = new Builder<>(Person.class)
    .set(Person::setName, "张三")
    .set(Person::setAge, 25)
    .build();

快速参考

泛型语法速查表

常用类型参数命名约定

核心原则与最佳实践

PECS 原则（Producer Extends, Consumer Super）

// Producer（生产者）：从集合中读取数据 → 使用 extends
public static double sum(List<? extends Number> numbers) {
    double total = 0;
    for (Number n : numbers) {
        total += n.doubleValue(); // ✅ 可以读取
    }
    return total;
}

// Consumer（消费者）：向集合中写入数据 → 使用 super
public static void addIntegers(List<? super Integer> list) {
    list.add(1); // ✅ 可以写入
    list.add(2);
}

使用建议

• ✅ 优先使用泛型而非原始类型
• ✅ 优先使用泛型方法而非泛型类（更灵活）
• ✅ 使用 PECS 原则选择通配符
• ✅ 避免使用原始类型（Raw Type）
• ✅ 传递 Class<T> 对象解决类型擦除问题
• ✅ 使用 @SuppressWarnings("unchecked") 时要谨慎，并添加注释说明原因
• ❌ 不要忽略编译器的泛型警告
• ❌ 不要在新代码中使用原始类型

常见错误与解决方案

参考资源

• Java 官方文档 - Generics
• 《Java 编程思想》第 15 章 - 泛型
• 《Effective Java》第 5 章 - 泛型