从零开始深入理解泛型

​

这一篇内容有点多，但是肯定会很有帮助，很多内容来自《Java核心技术》和《EffectiveJava》（刚学Java的时候，这本中文版的书非常不建议阅读，本来就不是很好理解，加上令人崩溃的翻译，但是主要内容都写在了这篇最后一章）另外还参考了《Java学习笔记》（这本书虽然没那么出名，但是读起来很容易理解，非常适合入门）还有一些其他资料就不说了，最后就是自己的一些理解。后面部分很多代码都没有使用idea，所以可能一点点会有笔误，当做是个学习笔记好了。

1. 为什么要使用泛型

​ 泛型是java se 5.0版本中引入的，在此之前java中的集合，比如数组列表ArrayList中只维护一个Object数组引用，简单写成下面的形式。

public class ArrayList {
	private Object[] elements;
	public Object get(int idx) {
		...
	}
	public void set(Object obj) {
		...
	}
    public void add(Object obj) {
        ...
    }
}

那么使用的时候，比如根据下标获取元素写成

String str = (String)list.get(5);

​ 注意到，需要进行强制转换，如果保证了list里面放入的都是String类型倒还好，但是如果放入Integer类型类型呢？事实上什么类型都能放入，比如list.add(new File("xxx"))，编译不报错就导致我们在编译期还无法知道，只有等运行出错。而且就算向上转型成功，每次这个也很麻烦很难看。

​ 泛型则提供了一个很好的解决方案：类型参数（比如T,E,K,V），下面就是我们常用的使用泛型的方式。

ArrayList<String> list = new ArrayList<>();
list.add("hello");
list.add("world")
String word = list.get(0);

​ 指定了泛型类型后，可以保证每次添加到list中的是String类型，获得的时候也是该类型所以不需要进行转换。

​ 所以说，使用泛型的好处在哪？使得程序具有更好的可读性和安全性，优雅而且简便。

2. 泛型的初步使用

2.1 定义简单的泛型

​ 下面定义一个简单的泛型类Pair，我们只需要在意泛型参数而根本不需要注意数据存储细节。

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

    public void setFirst(T first) {
        this.first = first;
    }

    public void setSecond(T second) {
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }
}

​ 类型变量只有一个T，紧跟类名后写在了见客户<>里面，当然也可以有两个或多了类型变量，比如Pair。通常任意类型变量用T表示(多个的话可以补充使用U,S)，集合元素类型变量用E表示，键值对用K,V表示。

​ 比如现在给一个字符串类型的数组（或者其他能比较的类型的数组），我们需要写个方法来求最小和最大值，然后返回，这就可以使用到Pair。

public class PairTest {
    public static Pair<String> getMinMax(String[] strs){
        if(strs == null || strs.length == 0)return null;
        String min = strs[0];
        String max = strs[0];
        for(int i = 1; i < strs.length; i ++) {
            if(strs[i].compareTo(min)<0) min = strs[i];
            if(strs[i].compareTo(max)>0) max = strs[i];
        }
        return new Pair<>(min,max);
    }

    public static void main(String[] args) {
        String[] strs = {"a","b","c","d"};
        Pair<String> minMax = getMinMax(strs);
        System.out.println(minMax.getFirst() + "," + minMax.getSecond());// a,d
    }
}

2.2 泛型方法

​ 如果区分一个方法是泛型方法或者定义一个泛型方法？从尖括号和类型变量（）可以看出，放在修饰符后面，返回类型前面这样的一个方法就是泛型方法，比如下面就是一个简单的泛型方法。

/**
*放入length个t到list中
* @param t  放入list中的元素
* @param length  放入到list中t的数量
* @param   元素类型
* @return  list
*/
public static <T> List<T> makeList(T t, int length) {
    List<T> list = new ArrayList<>();
    for (int i = 0; i< length; i++) {
   		list.add(t);
    }
    return list;
}

​ 有几点需要说明，泛型方法可以定义在普通类中或者泛型类中。泛型方法一般定义成静态方法，工具类中通常都会定义泛型方法。比如jdk 1.8中的Collectors中定义的分组方法，点进去看就发现全都是这样的泛型方法。

public static <T, K, A, D>
    Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
                                          Collector<? super T, A, D> downstream) {
        return groupingBy(classifier, HashMap::new, downstream);
    }

2.3 类型变量的限定

考虑下面的求最小值的泛型方法

public static <T> T findMin(T[] arr) {
    //忽略初始校验
    T min = arr[0];
    for (T t : arr) {
    	if(t.compareTo(min)<0) min = t;
    }
    return min;
}

​ 乍一看是没问题的，但是编译肯定通过不了，因为不能保证类型变量T实现了Comparable接口，如果没实现那就不能去使用它的compareTo方法了，所以对泛型变量T需要加限制，即>，如果要实现多个接口那就使用符号&进行连接，改成下面的代码即可。

public static <T extends Comparable<T> & Serializable> T findMin(T[] arr) {
    //忽略初始校验
    T min = arr[0];
    for (T t : arr) {
    	if(t.compareTo(min)<0) min = t;
    }
    return min;
}

3. 类型擦除

​ 对虚拟机而言，没有泛型（泛型类）这一说法，所有的对象都属于普通类，也就是说，虚拟机执行字节码文件的时候，泛型的类型变量是会被擦出掉的。

​ 只要是一个泛型，那么它都会对应一个原始类型。具体的，原始类的名称就是泛型类去掉尖括号以及里面的类型变量和限定，即。同时擦除类型变量，替换为限定类型（无限定类型那么就替换为Object)，比如:

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

    public void setFirst(T first) {
        this.first = first;
    }

    public void setSecond(T second) {
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }
}

类型擦除后变成了下面的样子

public class Pair {
    private Object first;
    private Object second;
    public Pair(){
    }
    public Pair(Object first, Object second) {
        this.first = first;
        this.second = second;
    }

    public void setFirst(Object first) {
        this.first = first;
    }

    public void setSecond(Object second) {
        this.second = second;
    }

    public Object getFirst() {
        return first;
    }

    public Object getSecond() {
        return second;
    }
}

显然，Pair变成了Pair，即使是Pair也是变成了Pair。而类中的T由于没有加限定就全部变成了Object

如果泛型类如下

public class Interval<T extends Comparable<T> & Serializable> implements Serializable{
    private T lower;
    private T upper;
    public Interval(T first, T second){
        ...
    }
}

变成原始类型如下

public class Interval implements Serializable{
    private Comparable lower;
    private Comparable upper
    public Interval(Comparable first, Comparable second){
        ...
    }
}

​ 注意到，限定 & Serializable>全部擦掉。而类型变量由于有限定Comparable所以T全变成了Comparable。

​ 注意，如果有多个限定，比如上面就有两个限定Comparable,Serializable，那么T会替换为extends关键字后面出现的第一个限定类型。

​ 此时可能产生的疑问是，既然运行时会擦除泛型，那么下面这段代码为什么不需要强制转换？

Pair<User> p = new Pair<>(new User(1,"tom"),new User(2,"jack"));
User user = p.getFirst();//这里并不需要强制类型转换

​ 根据上面说的类型擦除，p.getFirst()返回的应该是Object类型，需要强转为User类型。实际上是返回Object类型后，编译器帮助我们插入了强制类型转换。也就是说，编译器将这个方法翻译两条虚拟机指令。

1. 对原始类型对象的原始方法getFirst的调用；
2. 将返回的Object类型强制转换为User类型。

而且，如果first,second两个域是public修饰的，那么下面的调用，编译器也会帮我们进行强制类型转换。

User user = p.first;

4. 约束与局限性

这章都是些琐碎的东西，即使不说也都知道。

4.1 不能使用基本类型作为泛型的类型变量

也就是使用Pair,Pair这种方式定义泛型是行不通的，应该使用 Pair,Pair。

4.2 类型判断只使用于原始类型

虚拟机中的对象总有一个特定的非泛型类型。因此，所有的类型判断只适用于原始类型。

比如下面的判断就是错误的

Pair<String> p = new Pair<>("a","b");
if(p instanceof Pair<String>){//编译失败 instanceof Pair更是大错特错

}

需要使用原始类型比较

Pair<String> p = new Pair<>("a","b");
if(p instanceof Pair){//编译通过

}

同样的道理，使用getClass()方法返回的总是原始类型

Pair<String> stringPair = new Pair<>("a","b");
Pair<Integer> integerPair = new Pair<>(1,2);
System.out.println(stringPair.getClass() == integerPair.getClass());//true

4.3 不能创建参数化类型的数组

比如以下创建方式编译就不能通过

Pair<Integer>[] pairs = new Pair<>[10];//ERROR

注意：声明Pair[] pairs是没有问题的，但是不能通过new Pair<>[10]的方式初始化数组。去掉尖括号，改成下面的创建方式即可

Pair[] pairs = new Pair[10];

4.4 不能实例化类型变量和泛型数组

即使不说，显然使用下面的方式创建对象都是错误的

new T(...);//ERROR
T.class;//ERROR
public Pair(){//ERROR
	first = new T[];//类型擦除后就是Object，肯定不说希望new Object()
	second = new T[]
}

创建泛型数组也是不可以的，看下面的例子

public static <T extends Comparable<T>> T findMin(T... arr) {
    T[] arr = new T[10];// 试图创建泛型数组，编译失败
}

​ 这是因为类型擦除后，就永远创建Comparable[2]数组，这显然是不合理的。如果数组仅仅作为一个泛型类的私有域，那么完全可以设置为Object数组，然后再获取原始的时候进行强制类型转换。比如ArrayList可以这样设计。

public class ArrayList<E> {
	private Object[] elements;
    public E get(int idx){
        return (E)elements[idx];
    }
}

如果将new T[10]改成new Object[10]呢？这样很危险，虽然编译能通过，但是运行可能会出问题。

public static <T extends Comparable<T>> T findMin(T... arr) {
    Object[] arr = new Object[10];
    ...
    return (T[])arr;
}

​ 比如传入的T是String类型，最后转换的时候，Object[] 转 Comparable 就会出现类型转换问题了。下面提供一个简单的解决办法，让用户提供一个数组构造器表达式即可。

public static > T findMin(IntFunction constr, T... arr) {
    T[] arr = constr.apply(10);
    ...
}

//使用
String s = 类名.findMin(new::String,"tom","jack","lucy")

4.5 泛型类的静态上下文中禁止使用类型变量

不能在静态域或者静态方法中使用，看下面的例子。

public class Singleton<T> {
    private static T singleton;// 编译不通过
    public static T getInstance(){// 编译不通过  返回类型问题
        return null;
    }
    public static int getCount(T t){// 编译不通过  参数类型问题
        return 1;
    }
}

这是因为，泛型擦除后，即使组开始定义了不同类型变量的泛型对象，但是结果实例域都是相同类型。结果都是同一个singleton。

5. 通配符

​ 我觉得说到目前为止说了一堆枯燥而头疼并且显得不是那么重要的东西，接下来的通配符则是泛型的精髓。前面3，4章都可以忘了，但是通配符一定得熟稔于心。

​ 首先说容易让人误解的一点，如下

//Manager继承了Employee   
Manager m = new Manager(10,"tom");
Employee e = m;//OK
Pair<Manager> pm = new Pair<>(xxxx);
Pair<Employee> pe = pm;// ERROR  编译不通过

虽然Manager是Employee的子类，但是Pair与Pair可没有任何关系。

5.1 通配符的子类型限定

​ 有限制通配符类型，比如List(这里叫做带有子类型限定的通配符) ，注意区分有限制类型参数。

表示虽然不知道T到底是什么类型，但是知道他是Employee的子类，来看一个打印雇员的例子

public static void printEmployee(Pair<Employee> p) {
    Employee first = p.getFirst();
    Employee second = p.getSecond();
    System.out.println(first.getName() + "," + second.getName());
}

​ 正如前面说所说到的，不能将Pair传递给该方法，这就导致了这个方法通用性很受限制。在这里可以使用通配符来解决，改成如下的形式。

public static void printEmployee(Pair<? extends Employee> p) {
	// 内容不变
}

​ 类型Pair是Pair的子类型。

​ 来看个出人意料但是又很重要的操作，

public static void printEmployee(Pair<? extends Employee> p) {
        p.setFirst(new Employee("jack"));//编译不通过
        Employee first = p.getFirst();
        Employee second = p.getSecond();
        System.out.println(first.getName() + "," + second.getName());
    }

​ 我们来看setFirst方法，似乎就是下面这个样子

public void setFirst(? extends Employee)

其实?表示是什么类型编译器并不知道，它只知道是Employee的某个子类，却不知道具体的类型，所以它拒绝传递过来的任何具体的类型，不管你是传递个Manager还是Employee,CEO,CFO编译都不能通过。但是getFirst就行，因为返回的类型必然是Employee的子类（可以这么理解）。

​ 也就是说，对于有限制通配符类型(通配符的子类型限定)，访问可以修改不可以。

​ 看下面的代码哪些能通过编译

public class Node <T>{
	
	private T value;
	
	private Node <T> next;
	
	public Node(T value, Node<T> next) {
		this.value = value;
		this.next = next;
	}
	
}
//下面哪些能耐通过编译
Node<? extends Fruit> node = new Node<>(new Apple(), null);
Object o = node.value;
node.value = null;
Apple apple = node.value;//编译不通过
node.value = new Apple();//编译不通过,因为如果一开始建立的时候指定了Banana，这里还用Apple赋那肯定就不行了

5.2 通配符的超类型限定

​ 超类型限定? super Manager，?意思是指泛型类型变量是什么不知道，但是知道是Manager的父类。其实就是有限通配符的extends改成了super，而且功能跟有限通配符是相反的，即访问不可以修改可以（可以为方法提供参数，但不能使用返回值）。我们来看Pair的两个方法。

void setFirst(? super Manager);
? super Manager getFirst();

​ 这不是java的语法，我们这样写出来只是为了看编译器到底想干嘛。

• 对于getFirst方法，虽然可以调用，但是只能用Object对象来接收返回的对象，其他任何Manager的父类都不行，毕竟?是不能确认具体的父类型。
• 对于setFirst方法，传入的参数要求是Manager或者是它的子类（注意：不是Manager的父类）。为什么不能是父类也很好理解，参数为? super Manager，?并不能确定具体的类型，所以任意一个父类都不好使。Object类型也不可以。写的是super但是为什么可以使用Manager的子类也不难理解，虽然?不能确定具体类型，但肯定可以确定它是Manager的父类，那么也就是Manager子类的父类的父类，来接收孙子类是没问题的（我是这样理解的）。

来看下面的小案例：

public static void printEmployee2(Pair<? super Manager> p) {
    Object first = p.getFirst();//返回类型只能是Object
    p.setFirst(new Executive("tom"));//Executive是Manager子类   没问题
    p.setFirst(new Employee("jack"));//Employee是Manager父类  编译不通过  
}

来看个典型案例：给出一个经理数组，将奖金最高和最低的经理放到Pair里面返回。在这里传入Pair,Pair