泛型

泛型是一种代码模板，可以用一套代码套用各种类型。本节我们详细讨论Java的泛型编程。

什么是泛型

在介绍什么是泛型之前，我们先观察Java标准库提供的ArrayList，它可以看作“可变长度”的数组，因为用起来比数组更方便。

实际上ArrayList内部就是一个Object[]数组，配合存储一个当前分配的长度，就可以充当可变长度的数组。但如果用上述ArrayList存储String类型，会有两个缺点：

• 需要强制转型
• 不方便，易出错

ArrayList list = new ArrayList();
list.add("Hello");
// 获取到Object，必须强制转型为String:
String first = (String) list.get(0);

因为容易误转型，所以很容易出现ClassCastException。要解决上述问题，我们可以为String单独编写一种ArrayList：

public class StringArrayList {
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}

这样一来，存入的必须是String，取出的也一定是String，不需要强制转型，因为编译器会强制检查放入的类型。暂时解决了上述问题。

但新的问题又出现了，如果要存储Integer，还需要为Integer单独编写一种ArrayList，实际上，还需要为其他所有class单独编写一种ArrayList。这是不可能的，JDK的class就有上千个。

为了解决新的问题，我们必须把ArrayList变成一种模板：ArrayList<T>，代码如下：

public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

T可以是任何class。这样一来，我们就实现了，编写一次模板，可以创建任意类型的ArrayList。

// 创建可以存储String的ArrayList:
ArrayList<String> strList = new ArrayList<String>();
// 创建可以存储Float的ArrayList:
ArrayList<Float> floatList = new ArrayList<Float>();
// 创建可以存储Person的ArrayList:
ArrayList<Person> personList = new ArrayList<Person>();

因此，泛型就是定义一种模板，然后在代码中为用到的类创建对应的ArrayList<类型>，由编译器针对类型做检查。这样一来，即实现了编写一次，万能匹配，又通过编译器保证了类型安全。

向上转型

在Java标准库中的ArrayList<T>实现了List<T>接口，它可以向上转型为List<T>。要特别注意，不能把ArrayList<Integer>向上转型为ArrayList<Number>或List<Number>。

我们把一个ArrayList<Integer>转型为ArrayList<Number>类型后，这个ArrayList<Number>就可以接受Float类型，因为Float是Number的子类。但是，ArrayList<Number>实际上和ArrayList<Integer>是同一个对象，也就是ArrayList<Integer>类型，它不可能接受Float类型， 所以在获取Integer的时候将产生ClassCastException。

实际上，编译器为了避免这种错误，根本就不允许把ArrayList<Integer>转型为ArrayList<Number>。

注意泛型的继承关系：可以把ArrayList<Integer>向上转型为List<Integer>（T不能变！），但不能把ArrayList<Integer>向上转型为ArrayList<Number>（T不能变成父类）。

使用泛型

使用ArrayList时，如果不定义泛型类型，泛型类型实际上就是Object。此时，只能把<T>当Object使用，没有发挥泛型的优势。

当我们定义泛型类型<String>后，List<T>的泛型接口变为强类型List<String>。当我们定义泛型类型<Number>后，List<T>的泛型接口变为强类型List<Number>。编译器如果能自动推断出泛型类型，就可以省略后面的泛型类型。编译器看到泛型类型List<Number>就可以自动推断出后面的ArrayList<T>的泛型类型必须是ArrayList<Number>。

List<String> strlist = new ArrayList<String>();
List<Number> numlist = new ArrayList<Number>();
// 可以省略后面的Number，编译器可以自动推断泛型类型：
List<Number> numlist2 = new ArrayList<>();

泛型接口

还可以在接口中使用泛型。例如，Arrays.sort(Object[])可以对任意数组进行排序，但待排序的元素必须实现Comparable<T>这个泛型接口。可以直接对String数组进行排序，因为String本身已经实现了Comparable<String>接口。

public interface Comparable<T> {
    /**
     * 返回负数: 当前实例比参数o小
     * 返回0: 当前实例与参数o相等
     * 返回正数: 当前实例比参数o大
     */
    int compareTo(T o);
}

// sort
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Person[] ps = new Person[] {
            new Person("Bob", 61),
            new Person("Alice", 88),
            new Person("Lily", 75),
        };
        Arrays.sort(ps);
        System.out.println(Arrays.toString(ps));
    }
}
class Person implements Comparable<Person> {
    String name;
    int score;
    Person(String name, int score) {
        this.name = name;
        this.score = score;
    }
    public int compareTo(Person other) {//也可以修改逻辑，按score从高到低排序
        return this.name.compareTo(other.name);
    }
    public String toString() {
        return this.name + "," + this.score;
    }
}

编写泛型

编写泛型类比普通类要复杂。通常来说，泛型类一般用在集合类，例如ArrayList<T>，我们很少需要编写泛型类。如果我们确实需要编写一个泛型类，那么应该怎么编写呢？

首先，按照某种类型，例如String，来编写类。然后标记所有的特定类型，这里是String。最后把特定类型String替换为T，并声明<T>。熟练之后可以直接从T开始编写。

public class Pair {
    private String first;
    private String last;
    public Pair(String first, String last) {
        this.first = first;
        this.last = last;
    }
    public String getFirst() {
        return first;
    }
    public String getLast() {
        return last;
    }
}

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

静态方法

编写泛型类时，要特别注意，泛型类型<T>不能用于静态方法。例如：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public T getLast() { ... }

    // 对静态方法使用<T>:
    public static Pair<T> create(T first, T last) {
        return new Pair<T>(first, last);
    }
}

上述代码会导致编译错误，我们无法在静态方法creat()的方法参数和返回类型上使用泛型类型T。对于静态方法，我们可以单独改写为泛型方法，只需要使用另一个类型就好了。这样才能清楚地将静态方法的泛型类型和实例类型的泛型类型区分开。

普通的方法是通过类的实例来调用的，创建实例的过程调用了构造方法，也就是说对象已经知道这个时候类上面定义的的具体类型了；而静态方法不需要对象实例来调用，所以也就不知道的具体类型，虚拟机不允许这种情况发生，所以编译的时候就报错了。

或者说静态方法由于随着类的加载而加载，不能访问类的泛型（因为在创建对象的时候才确定），因此必须定义自己的泛型类型。

// 静态泛型方法应该使用其他类型区分:
public static <K> Pair<K> create(K first, K last) {
	return new Pair<K>(first, last);
}

多个泛型类型

泛型还可以定义多种类型。例如，我们希望Pair不总是存储两个类型一样的对象，就可以使用类型<T, K>。

public class Pair<T, K> {
    private T first;
    private K last;
    public Pair(T first, K last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public K getLast() { ... }
}

使用的时候，需要指出两种类型：Pair<String, Integer> p = new Pair<>("test", 123);。

Java标准库的Map<K, V>就是使用两种泛型类型的例子。它对Key使用一种类型，对Value使用另一种类型。

擦拭法

泛型是一种类似“模板代码”的技术，不同语言的泛型实现方式不一定相同。Java语言的泛型实现方法是擦拭法（Type Erasure）。所谓擦拭法，是指虚拟机对泛型其实一无所知，所有的工作都是编译器做的。

• 编译器把类型<T>视为Object
• 编译器根据<T>实现安全的强制转型

所以，Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型<T>视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动为我们实现安全地强制转型。了解了Java泛型的实现方法，我们就知道了Java泛型的局限。

• 局限一：<T>不能是基本类型，因为实际类型是Object，Object类型无法持有基本类型。
• 局限二：无法取得带泛型的Class，换句话说，所有泛型实例无论T的类型是什么，getClass()返回同一个Class实例，因为它们编译后全都是Pair<Object>。
• 局限三：无法判断带泛型的类型。原因同局限二。

Pair<Integer> p = new Pair<>(123, 456);
// Compile error:
if (p instanceof Pair<String>) {
}

• 局限四：不能实例化T类型。

public class Pair<T> {
    private T first;
    private T last;
    public Pair() {
        // Compile error:
        // 因为擦拭后，下面两句分别变为first = new Object();last = new Object();
        // 这样一来，创建new Pair<String>()和new Pair<Integer>()就全部变成了Object
        // 编译器会阻止这种类型不对的代码
        first = new T();
        last = new T();
    }
}

要实例化T类型，我们必须借助额外的Class<T>参数，借助Class<T>参数并通过反射来实例化T类型，使用的时候，也必须传入Class<T>。

public class Pair<T> {
    private T first;
    private T last;
    public Pair(Class<T> clazz) {
        first = clazz.newInstance();
        last = clazz.newInstance();
    }
}

Pair<String> pair = new Pair<>(String.class);//因为传入了Class<String>的实例，所以我们借助String.class就可以实例化String类型。

不恰当的覆写方法

有时候，一个看似正确定义的方法会无法通过编译，比如：

public class Pair<T> {
    public boolean equals(T t) {
        return this == t;
    }
}

这是因为，定义的equals(T t)方法实际上会被擦拭成equals(Object t)，而这个方法是继承自Object的，编译器会阻止一个实际会变成覆写的泛型方法的定义。换个方法名，比如same，避开Object.equals(Object)的冲突就可以成功编译。

泛型继承

一个类可以继承自一个泛型类。例如：父类的类型是Pair<Integer>，子类的类型是IntPair，可以这么继承：

public class IntPair extends Pair<Integer> {
}

使用的时候，因为子类IntPair并没有泛型继承，所以正常使用即可。

IntPair ip = new IntPair(1, 2);

前面讲了，我们无法获取Pair<T>的T类型，即给定一个变量Pair<Integer> p，无法从p中获取到Integer类型。但是，在父类是泛型类型的情况下，编译器就必须把类型T保存到子类的class文件中，不然编译器就不知道IntPair只能存取Integer这种类型。

在继承了泛型类型的情况下，子类可以获取父类的泛型类型。代码较为复杂，这里就不贴了。

小结

Java的泛型是采用擦拭法实现的；

擦拭法决定了泛型<T>：

• 不能是基本类型，例如：int；
• 不能获取带泛型类型的Class，例如：Pair<String>.class；
• 不能判断带泛型类型的类型，例如：x instanceof Pair<String>；
• 不能实例化T类型，例如：new T()。

泛型方法要防止重复定义方法，例如：public boolean equals(T obj)；

子类可以获取父类的泛型类型<T>。

extends通配符

我们前面已经讲到泛型的继承关系：Pair<Integer>不是Pair<Number>的子类。假设我们定义了Pair<T>，然后又针对Pair<Number>类型写了一个静态方法，它接受的参数类型是Pair<Number>。

public class Pair<T> { ... }
public class PairHelper {
    static int add(Pair<Number> p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        return first.intValue() + last.intValue();
    }
}

上述代码是可以正常编译的，使用的时候，我们传入：

int sum = PairHelper.add(new Pair<Number>(1, 2));

注意，传入的类型是Pair<Number>，实际参数类型是<Integer, Integer>。既然实际参数是Integer类型，试试传入Pair<Integer>。

直接运行会得到一个编译错误，原因很明显，因为Pair<Integer>不是Pair<Number>的子类，因此add(Pair<Number>)不接受参数类型Pair<Integer>。但是从add()方法的代码可知，传入Pair<Integer>完全符合内部代码的类型规范，因为语句：

Number first = p.getFirst();
Number last = p.getLast();

实际类型是Integer，引用类型是Number，没有问题。问题在于方法参数类型定死了只能传入Pair<Number>。

有没有办法使得方法参数接受Pair<Integer>？办法是有的，这就是使用Pair<? extends Number>使得方法接受所有泛型类型为Number及其子类的Pair类型。

static int add(Pair<? extends Number> p) {
    Number first = p.getFirst();
    Number last = p.getLast();
    return first.intValue() + last.intValue();
}

这样一来，给方法传入Pair<Integer>类型时，它符合参数Pair<? extends Number>类型。这种使用<? extends Number>的泛型定义称之为上界通配符（Upper Bounds Wildcards），即把泛型类型T的上界限定在Number了。

除了可以传入Pair<Integer>类型，我们还可以传入Pair<Double>类型，Pair<BigDecimal>类型等等，因为Double和BigDecimal都是Number的子类。

<? extends Number>通配符的一个重要限制：方法参数签名无法传递任何Number的子类型。这里唯一的例外是可以给方法参数传入null。

static int add(Pair<? extends Number> p) {
    Number first = p.getFirst();
    Number last = p.getLast();
    p.setFirst(new Integer(first.intValue() + 100));// 
    p.setLast(new Integer(last.intValue() + 100));//
    return p.getFirst().intValue() + p.getFirst().intValue();
}

extends通配符的作用

使用extends通配符只能读，不能写。

使用extends限定T类型

在定义泛型类型Pair<T>的时候，也可以使用extends通配符来限定T的类型。因为Number、Integer和Double都符合<T extends Number>。而非Number类型将无法通过编译。

public class Pair<T extends Number> { ... }
Pair<Number> p1 = null;
Pair<Integer> p2 = new Pair<>(1, 2);
Pair<Double> p3 = null;
Pair<String> p1 = null; // compile error!
Pair<Object> p2 = null; // compile error!

小结

使用类似<? extends Number>通配符作为方法参数时表示：

• 方法内部可以调用获取Number引用的方法，例如：Number n = obj.getFirst();；
• 方法内部无法调用传入Number引用的方法（null除外），例如：obj.setFirst(Number n);。

即一句话总结：使用extends通配符表示可以读，不能写。

使用类似<T extends Number>定义泛型类时表示：

• 泛型类型限定为Number以及Number的子类。

super通配符

使用<? super Integer>通配符表示：

• 允许调用set(? super Integer)方法传入Integer的引用；
• 不允许调用get()方法获得Integer的引用。

唯一例外是可以获取Object的引用：Object o = p.getFirst()。

换句话说，使用<? super Integer>通配符作为方法参数，表示方法内部代码对于参数只能写，不能读。

对比extends和super通配符

作为方法参数，<? extends T>类型和<? super T>类型的区别在于：

• <? extends T>允许调用读方法T get()获取T的引用，但不允许调用写方法set(T)传入T的引用（传入null除外）
• <? super T>允许调用写方法set(T)传入T的引用，但不允许调用读方法T get()获取T的引用（获取Object除外）

一个是允许读不允许写，一个是允许写不允许读。

先记住上面的结论，我们来看Java标准库的Collections类定义的copy()方法：

public class Collections {
    // 把src的每个元素复制到dest中:
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        for (int i=0; i<src.size(); i++) {
            T t = src.get(i);
            dest.add(t);
        }
    }
}

它的作用是把每一个List的每个元素依次添加到另一个List。它的第一个参数是List<? super T>，表示目标List，第二个参数List<? extends T>，表示要复制的List。我们可以简单地用for循环实现复制。在for循环中，我们可以看到，对于类型<? extends T>的变量src，我们可以安全地获取类型T的引用，而对于类型<? super T>的变量dest，我们可以安全地传入T的引用。

这个copy()方法的定义就完美地展示了extends和super的意图：

• copy()方法内部不会读取dest，因为不能调用dest.get()来获取T的引用；
• copy()方法内部也不会修改src，因为不能调用src.add(T)。

这是由编译器检查来实现的。如果在方法代码中意外修改了src，或者意外读取了dest，就会导致一个编译错误。

这个copy()方法的另一个好处是可以安全地把一个List<Integer>添加到List<Number>，但是反过来无法添加。

这些都是通过super和extends通配符，并由编译器强制检查实现的。

PECS原则

何时使用extends，何时使用super？为了便于记忆，我们可以用PECS原则：Producer Extends Consumer Super。

即：如果需要返回T，它是生产者（Producer），要使用extends通配符；如果需要写入T，它是消费者（Consumer），要使用super通配符。

无限定通配符

实际上，Java的泛型还允许使用无限定通配符（Unbounded Wildcard Type），即只定义一个?：

void sample(Pair<?> p) {
}

因为<?>通配符既没有extends，也没有super，因此：

• 不允许调用set(T)方法并传入引用（null除外）；
• 不允许调用T get()方法并获取T引用（只能获取Object引用）。

换句话说，既不能读，也不能写，那只能做一些null判断：

static boolean isNull(Pair<?> p) {
    return p.getFirst() == null || p.getLast() == null;
}

大多数情况下，可以引入泛型参数<T>消除<?>通配符：

static <T> boolean isNull(Pair<T> p) {
    return p.getFirst() == null || p.getLast() == null;
}

<?>通配符有一个独特的特点，就是：Pair<?>是所有Pair<T>的超类。

泛型和反射

Java的部分反射API也是泛型。例如，Class<T>就是泛型。

// compile warning:
Class clazz = String.class;
String str = (String) clazz.newInstance();

// no warning:
Class<String> clazz = String.class;
String str = clazz.newInstance();

调用Class的getSuperclass()方法返回的Class类型是Class<? super T>：

Class<? super String> sup = String.class.getSuperclass();

构造方法Constructor<T>也是泛型：

Class<Integer> clazz = Integer.class;
Constructor<Integer> cons = clazz.getConstructor(int.class);
Integer i = cons.newInstance(123);

我们可以声明带泛型的数组，但不能用new操作符创建带泛型的数组。必须通过强制转型实现带泛型的数组。

Pair<String>[] ps = null; // ok
Pair<String>[] ps = new Pair<String>[2]; // compile error!

@SuppressWarnings("unchecked")
Pair<String>[] ps = (Pair<String>[]) new Pair[2];

使用泛型数组要特别小心，因为数组实际上在运行期没有泛型，编译器可以强制检查变量ps，因为它的类型是泛型数组。但是，编译器不会检查变量arr，因为它不是泛型数组。因为这两个变量实际上指向同一个数组，所以，操作arr可能导致从ps获取元素时报错，例如，以下代码演示了不安全地使用带泛型的数组：

Pair[] arr = new Pair[2];
Pair<String>[] ps = (Pair<String>[]) arr;

ps[0] = new Pair<String>("a", "b");
arr[1] = new Pair<Integer>(1, 2);

// ClassCastException:
Pair<String> p = ps[1];
String s = p.getFirst();

要安全地使用泛型数组，必须扔掉arr的引用，由于拿不到原始数组的引用，就只能对泛型数组ps进行操作，这种操作就是安全的。

@SuppressWarnings("unchecked")
Pair<String>[] ps = (Pair<String>[]) new Pair[2];

带泛型的数组实际上是编译器的类型擦除，所以我们不能直接创建泛型数组T[]，因为擦拭后代码变成Object[]。必须借助Class<T>来创建泛型数组。

// compile error:
public class Abc<T> {
    T[] createArray() {
        return new T[5];
    }
}

T[] createArray(Class<T> cls) {
    return (T[]) Array.newInstance(cls, 5);
}

我们还可以利用可变参数创建泛型数组T[]：

public class ArrayHelper {
    @SafeVarargs
    static <T> T[] asArray(T... objs) {
        return objs;
    }
}

String[] ss = ArrayHelper.asArray("a", "b", "c");
Integer[] ns = ArrayHelper.asArray(1, 2, 3);

谨慎使用泛型可变参数

public class Main {
    public static void main(String[] args) {
        String[] arr = asArray("one", "two", "three");
        System.out.println(Arrays.toString(arr));
        // ClassCastException:
        String[] firstTwo = pickTwo("one", "two", "three");
        System.out.println(Arrays.toString(firstTwo));
    }

    static <K> K[] pickTwo(K k1, K k2, K k3) {
        return asArray(k1, k2);
    }

    static <T> T[] asArray(T... objs) {
        return objs;
    }
}

直接调用asArray(T...)似乎没有问题，但是在另一个方法中，我们返回一个泛型数组就会产生ClassCastException，原因还是因为擦拭法，在pickTwo()方法内部，编译器无法检测K[]的正确类型，因此返回了Object[]。如果仔细观察，可以发现编译器对所有可变泛型参数都会发出警告，除非确认完全没有问题，才可以用@SafeVarargs消除警告。如果在方法内部创建了泛型数组，最好不要将它返回给外部使用。