Java中的泛型：通配符（Wildcard）上下界与PECS原则的深度应用 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Java泛型：通配符上下界与PECS原则的深度应用

大家好，今天我们来深入探讨Java泛型中一个非常重要的概念：通配符（Wildcard）及其上下界，以及与它们紧密相关的PECS（Producer Extends, Consumer Super）原则。泛型是Java 5引入的一项强大的特性，它允许我们在编译时进行类型检查，从而提高代码的类型安全性和可重用性。通配符是泛型类型系统中一个关键组成部分，它允许我们在处理泛型类型时具有更大的灵活性，尤其是当涉及到集合和继承关系时。

1. 泛型基础回顾

在深入研究通配符之前，我们先简单回顾一下泛型的基本概念。泛型的主要目标是参数化类型。也就是说，我们可以定义一个类或方法，使其能够处理不同类型的数据，而无需为每种类型编写不同的代码。

// 泛型类
class Box<T> {
    private T t;

    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

// 泛型方法
public static <E> void printArray(E[] inputArray) {
    for (E element : inputArray) {
        System.out.printf("%s ", element);
    }
    System.out.println();
}

public static void main(String[] args) {
    Box<Integer> integerBox = new Box<>();
    integerBox.set(10);
    Integer integerValue = integerBox.get();
    System.out.println("Integer Value: " + integerValue);

    Box<String> stringBox = new Box<>();
    stringBox.set("Hello");
    String stringValue = stringBox.get();
    System.out.println("String Value: " + stringValue);

    Integer[] intArray = { 1, 2, 3, 4, 5 };
    String[] stringArray = { "H", "e", "l", "l", "o" };
    printArray(intArray);
    printArray(stringArray);
}

在这个例子中，Box<T> 是一个泛型类，T 是类型参数。我们可以使用不同的类型参数来创建 Box 类的实例，例如 Box<Integer> 和 Box<String>。 printArray 是一个泛型方法，它可以接受任何类型的数组作为参数。

2. 为什么需要通配符？

考虑以下情况：我们有一个方法，它接受一个 List<Object> 作为参数，并将列表中的所有元素打印出来。

public static void printList(List<Object> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

现在，如果我们尝试将一个 List<String> 传递给这个方法，会发生什么？

List<String> stringList = new ArrayList<>();
stringList.add("Hello");
stringList.add("World");
//printList(stringList); // 编译错误：Required type: List<Object>  Provided: List<String>

我们会得到一个编译错误。尽管 String 是 Object 的子类，但 List<String> 不是 List<Object> 的子类型。这就是泛型的一个关键限制：泛型类型不是协变的。也就是说，如果 B 是 A 的子类型，那么 GenericType<B> 不是 GenericType<A> 的子类型。

为了解决这个问题，我们需要使用通配符。

3. 通配符：?

通配符 ? 表示一个未知的类型。它可以用于表示任何类型。例如，List<?> 表示一个元素类型未知的列表。

public static void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

public static void main(String[] args) {
    List<String> stringList = new ArrayList<>();
    stringList.add("Hello");
    stringList.add("World");
    printList(stringList); // 现在可以正常编译和运行了

    List<Integer> integerList = new ArrayList<>();
    integerList.add(1);
    integerList.add(2);
    printList(integerList); // 同样可以正常编译和运行
}

现在，printList 方法可以接受任何类型的列表作为参数。但是，使用 List<?> 也带来了一些限制。由于我们不知道列表的元素类型，我们不能向列表中添加任何元素（除了 null）。

public static void addToList(List<?> list, Object obj) {
    //list.add(obj); // 编译错误：Required type: capture of ?  Provided: Object
}

因为编译器无法确定 list 中元素的具体类型，所以它无法保证 obj 的类型与列表的元素类型兼容。

4. 通配符上界：? extends Type

通配符上界 ? extends Type 表示一个未知的类型，但它必须是 Type 或 Type 的子类型。这允许我们在处理泛型类型时具有更大的灵活性，同时仍然保持一定的类型安全。

public static double sumOfList(List<? extends Number> list) {
    double sum = 0;
    for (Number n : list) {
        sum += n.doubleValue();
    }
    return sum;
}

public static void main(String[] args) {
    List<Integer> integerList = new ArrayList<>();
    integerList.add(1);
    integerList.add(2);
    System.out.println("Sum of integer list: " + sumOfList(integerList));

    List<Double> doubleList = new ArrayList<>();
    doubleList.add(1.1);
    doubleList.add(2.2);
    System.out.println("Sum of double list: " + sumOfList(doubleList));
}

在这个例子中，sumOfList 方法可以接受任何元素类型是 Number 或 Number 的子类的列表作为参数。这使得我们可以计算 Integer 列表、Double 列表等数字列表的总和。

同样，使用通配符上界也存在一些限制。我们不能向 List<? extends Number> 中添加任何元素，因为我们不知道列表的元素类型到底是什么。它可能是 Integer、Double 或其他 Number 的子类。为了保证类型安全，编译器不允许我们添加任何元素。

public static void addToList(List<? extends Number> list, Number number) {
    //list.add(number); // 编译错误：Required type: capture of ? extends Number  Provided: Number
}

5. 通配符下界：? super Type

通配符下界 ? super Type 表示一个未知的类型，但它必须是 Type 或 Type 的父类型。这在我们需要将元素添加到泛型集合中时非常有用。

public static void addIntegers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
}

public static void main(String[] args) {
    List<Integer> integerList = new ArrayList<>();
    addIntegers(integerList);
    System.out.println("Integer list: " + integerList);

    List<Number> numberList = new ArrayList<>();
    addIntegers(numberList);
    System.out.println("Number list: " + numberList);

    List<Object> objectList = new ArrayList<>();
    addIntegers(objectList);
    System.out.println("Object list: " + objectList);
}

在这个例子中，addIntegers 方法可以接受任何元素类型是 Integer 或 Integer 的父类的列表作为参数。这意味着我们可以将整数添加到 Integer 列表、Number 列表或 Object 列表。

使用通配符下界时，我们可以向列表中添加 Type 类型的元素，因为我们知道列表的元素类型一定是 Type 或 Type 的父类型。但是，我们不能从列表中读取元素并将其赋值给 Type 类型的变量，因为列表的元素类型可能是 Type 的父类型。

public static void processList(List<? super Integer> list) {
    //Integer i = list.get(0); // 编译错误：Required type: Integer  Provided: capture of ? super Integer
    Object o = list.get(0); //  只能赋值给Object
}

6. PECS原则：Producer Extends, Consumer Super

PECS原则是一个指导我们何时使用通配符上界和下界的最佳实践。它代表：

Producer extends: 如果你需要从一个泛型类型中读取数据（生产者），使用 ? extends Type。
Consumer super: 如果你需要向一个泛型类型中写入数据（消费者），使用 ? super Type。

如果既要读取数据又要写入数据，则不应使用通配符。

我们可以用一张表格来总结PECS原则：

操作	场景	通配符	示例
读取 (Produce)	从泛型类型中读取数据，作为生产者	`? extends Type`	`List<? extends Number>` (可以读取 Number 或 Number 的子类)
写入 (Consume)	向泛型类型中写入数据，作为消费者	`? super Type`	`List<? super Integer>` (可以写入 Integer，因为列表类型可以是 Integer, Number, Object)
既读又写	既需要读取数据，又需要写入数据	无通配符	`List<Integer>` (只能读取和写入 Integer)

让我们通过一些例子来进一步理解PECS原则。

例1：复制列表

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    for (T t : src) {
        dest.add(t);
    }
}

public static void main(String[] args) {
    List<Integer> integerList = new ArrayList<>();
    integerList.add(1);
    integerList.add(2);

    List<Number> numberList = new ArrayList<>();
    copy(numberList, integerList); // integerList 是生产者，numberList 是消费者
    System.out.println("Number list: " + numberList);

    List<Object> objectList = new ArrayList<>();
    copy(objectList, integerList); // integerList 是生产者，objectList 是消费者
    System.out.println("Object list: " + objectList);
}

在这个例子中，src 列表是生产者，因为它提供数据。我们使用 ? extends T 来允许 src 列表包含 T 或 T 的子类型的元素。 dest 列表是消费者，因为它接收数据。我们使用 ? super T 来允许 dest 列表包含 T 或 T 的父类型的元素。

例2：比较器

public static <T> T max(List<? extends T> list, Comparator<? super T> comparator) {
    if (list == null || list.isEmpty()) {
        return null;
    }

    T max = list.get(0);
    for (int i = 1; i < list.size(); i++) {
        T current = list.get(i);
        if (comparator.compare(current, max) > 0) {
            max = current;
        }
    }
    return max;
}

public static void main(String[] args) {
    List<Integer> integerList = new ArrayList<>();
    integerList.add(1);
    integerList.add(2);
    integerList.add(3);

    Comparator<Number> numberComparator = Comparator.comparing(Number::intValue);
    Integer maxInteger = max(integerList, numberComparator); // list 是生产者，comparator 是消费者
    System.out.println("Max integer: " + maxInteger);
}

在这个例子中，list 是生产者，因为它提供数据。我们使用 ? extends T 来允许 list 列表包含 T 或 T 的子类型的元素。 comparator 是消费者，因为它接收数据（用于比较）。我们使用 ? super T 来允许 comparator 比较 T 或 T 的父类型的元素。例如，我们可以使用一个 Comparator<Number> 来比较 Integer 列表中的元素。这是因为 Integer 是 Number 的子类。

7. 类型擦除（Type Erasure）

值得注意的是，Java泛型是通过类型擦除来实现的。这意味着在编译时，泛型类型信息会被擦除，并替换为它们的原始类型（raw type）。例如，List<String> 在运行时会变成 List。

类型擦除可能会导致一些令人困惑的行为。例如，我们不能在运行时使用 instanceof 运算符来检查泛型类型。

List<String> stringList = new ArrayList<>();
//if (stringList instanceof List<String>) { // 编译错误：Illegal generic type for instanceof
//}

if (stringList instanceof List) { // 这是合法的
    System.out.println("stringList is a List");
}

这是因为在运行时，stringList 只是一个 List，而不是 List<String>。

8. 泛型数组

创建泛型数组需要特别小心。由于类型擦除，我们不能直接创建泛型数组。

//T[] array = new T[10]; // 编译错误：Cannot create a generic array of T

但是，我们可以使用一些技巧来绕过这个限制。例如，我们可以使用 Array.newInstance() 方法来创建一个具有特定类型的数组。

public static <T> T[] createArray(Class<T> type, int size) {
    @SuppressWarnings("unchecked")
    T[] array = (T[]) Array.newInstance(type, size);
    return array;
}

public static void main(String[] args) {
    Integer[] intArray = createArray(Integer.class, 10);
    System.out.println("Integer array: " + Arrays.toString(intArray));
}

9. 总结：用好通配符，代码更灵活

总而言之，通配符是Java泛型中一个非常重要的概念。它们允许我们在处理泛型类型时具有更大的灵活性，特别是当涉及到集合和继承关系时。通过理解通配符的上界和下界，以及PECS原则，我们可以编写更加类型安全和可重用的代码。深入理解泛型与通配符的应用，能提升程序设计的灵活性与可维护性。在实际开发中，合理运用这些特性，可以极大地提高代码质量。

Java泛型：通配符上下界与PECS原则的深度应用

发表回复 取消回复

发表回复取消回复