Java泛型之通配符

使用通配符的原因：Java中的数组是协变的，但是泛型不支持协变。

数组的协变

首先了解下什么是数组的协变，看下面的例子：

Number[] nums = new Integer[10]; // OK

因为Integer是Number的子类，一个Integer对象也是一个Number对象，所以一个Integer的数组也是一个Number的数组，这就是数组的协变。

Java把数组设计成协变的，在一定程度上是有缺陷的。因为尽管把Integer[]赋值给Number[]，Integer[]可以向上转型为Number[]，但是数据元素的实际类型是Integer，只能向数组中放入Integer或者Integer的子类。如果向数组中放入Number对象或者Number其他子类的对象，对于编译器来说也是可以通过编译的。但是运行时JVM能够知道数组元素的实际类型是Integer，当其它对象加入数组是就会抛出异常（java.lang.ArrayStoreException）。

泛型的设计目的之一就是保证了类型安全，让这种运行时期的错误在编译期就能发现，所以泛型是不支持协变的。例如：

List<Number> nums = new ArrayList<Integer>(); // incompatible types

当确实需要建立这种向上转型的类型关系的时候，就需要用到泛型的通配符特性了。例如：

List<? extends Number> nums = new ArrayList<Integer>(); // OK

无边界通配符（Unbounded Wildcards）

语法：

class-name<?> var-name

例子：

public static void print(List<?> list) {

    for (Object obj : list) {

        System.out.println(o);

    }

}

List<?> list和List list的区别：

List<?> list是表示持有某种特定类型对象的List，但是不知道是哪种类型；List list是表示持有Object类型对象的List。
List<?> list因为不知道持有的实际类型，所以不能add任何类型的对象，但是List list因为持有的是Object类型对象，所以可以add任何类型的对象。
注意：List<?> list可以add(null)，因为null是任何引用数据类型都具有的元素。

Pair<?> 和 Pair 的区别：

Pair<?>的 ? getFirst()方法，返回值只能赋值给一个Object对象，它的void setFirst(? )方法不能被调用，甚至不能用Object调用。

为什么要使用这样脆弱的类型？它对于许多简单的操作非常有用。例如 ，下面这个方法将用来测试一个 pair 是否包含一个 mill 引用，它不需要实际的类型。

public static boolean hasNulls (Pair<?> p)

{

    return p.getFirstO = null | | p.getSecondO = null ;

}

通过将 hasNulls 转换成泛型方法,可以避免使用通配符类型：

public static <T> boolean hasNulls (Pair<T> p)

但是，带有通配符的版本可读性更强。

上边界限定的通配符（Upper Bounded Wildcards）

语法：

class-name<? extends superclass> var-name

例子：

public static double sum(List<? extends Number> list) {

    double s = 0.0;

    for (Number num : list) {

        s += num.doubleValue();

    }

    return s;

}

List<? extends Number> list = new ArrayList<Integer>(); // OK

List<? extends Number> list = new ArrayList<Object>(); // error

特性：

List<? extends Number> list表示某种特定类型（Number或者Number的子类）对象的List。跟无边界通配符一样，因为无法确定持有的实际类型，所以这个List也不能add除null外的任何类型的对象。

list.add(new Integer(1)); // error

list.add(null); // OK

从list中获取对象是是可以的（比如get(0)），因为在这个List中，不管实际类型是什么，但肯定都能转型为Number。

Number n = list.get(0); // OK

Integer i = list.get(0); // error

事实上，只要是形式参数有使用类型参数的方法，在使用无边界或者上边界限定的通配符的情况下，都不能调用。比如以java.util.ArrayList为例：

public E get(int index) // 可以调用

public int indexOf(Object o) // 可以调用

public boolean add(E e) // 不能调用

下边界限定的通配符（Lower Bounded wildcards）

语法：

class-name<? super subclass> var-name

例子：

public static void writeTo(List<? super Integer> list) {

    // ...

}

List<? super Number> list = new ArrayList<Number>(); // OK

List<? super Number> list = new ArrayList<Object>(); // OK

List<? super Number> list = new ArrayList<Integer>(); // error

特性：

List<? super Integer> list表示某种特定类型（Integer或者Integer的父类）对象的List。可以确定这个List持有的对象类型肯定是Integer或者其父类，所以往list里面add一个Integer或者其子类的对象是安全的，因为Integer或者其子类的对象都可以向上转型为Integer的父类对象。但是因为无法确定实际类型，所以往list里面add一个Integer的父类对象是不安全的。

list.add(new Integer(1)); // OK

list.add(new Object()); // error

当从List<? super Integer> list获取具体的数据的时候，JVM在编译的时候知道实际类型可以是任何Integer的父类，所以为了安全起见，要用一个最顶层的父类对象来指向取出的数据，这样就可以避免发生强制类型转换异常了。

Object obj = list.get(0); // OK

Integer i = list.get(0); // error

PECS原则（Producer Extends Consumer Super）

从上面上边界限定的通配符和下边界限定的通配符的特性，可以知道：

对于上边界限定的通配符，无法向其中加入任何对象，但是可以从中正常取出对象。
对于下边界限定的通配符，可以存入subclass对象或者subclass的子类对象，但是取出时只能用Object类型变量指向取出的对象。

简而言之，上边界限定（extends）的通配符适合于内容的获取，而下边界限定（super）的通配符更适合于内容的存入。所以就有了一个PECS原则来很好的解释这两种通配符的使用原则。

当一个数据结构作为producer对外提供数据的时候，应该只能取数据而不能存数据，所以适合使用上边界限定（extends）的通配符。
当一个数据结构作为consumer获取并存入数据的时候，应该只能存数据而不能取数据，所以适合使用下边界限定（super）的通配符。
如果既需要取数据也需要存数据，就不适合使用泛型的通配符。

public static <T> void copy(List<? super T> dest, List<? extends T> src) {

    for (int i = 0; i < src.size(); i++) {

        dest.set(i, src.get(i));

    }

}