Java 中的泛型
先来看一下以下 2 段代码，然后再进一步引出我们的泛型。
public static void main(String[] args) { List list = new ArrayList(); list.add("123"); list.add(456); Iterator it = list.iterator(); while(it.hasNext()){ // Error : Integer cannot be cast to String String next = (String)it.next(); } }
上面这段代码，会出现转化异常的情况，但是编译是没问题的，在输出转化的时候却出现了异常，有没有一种冲动想要把集合中的类型归一？下面就是很正常的一个求和的方法，然而我们只能求类型为 Integer 的参数的和。
public Integer add(Integer a,Integer b){ return a + b; }
对于集合来说，我们若是能在编译时期指定该集合中存放数据的类型，这样在类型转化的时候就不会再出现错误了，同样的，在下面的求和方法中，这个方法我们只能求得类型为 Integer 的参数的和，我们能不能做到可以通用的求和呢？使用泛型，就可以做到。
泛型的概念也就是 “ 数据类型参数化 ” 正是由于我们不确定集合中可以指定的类型有哪些，是 Integer 还是 String ？求和方法中参数的数据类型可以有哪些，是 Float 还是 Double ？那我们就可以使用泛型来把这个数据类型给参数化。
泛型的应用有泛型接口，泛型类和泛型方法。下面定义一个泛型类，并演示使用方式。
public class Box <T> { // T 是 Type 的简写,代表任意类型，注意是类，而不是基本数据类型。 // 也可以换成其它单词，这只是一个表示而已。 T t; public T getT() { return t; } public void setT(T t) { this.t = t; } // 在下面的应用中，我们可以将 T 换成任意我们想要的类型 public static void main(String[] args) { Box<Integer> iBox = new Box<Integer>(); Box<Double> dBox = new Box<Double>(); // 在 JDK1.7 及其以上版本可以利用 “类型推断” 这样写。 Box<String> stringBox = new Box<>(); } }
泛型方法的定义只需要在方法的声明中添加 < T > 即可，或是添加一组泛型 <K ，V> 。
public class Util { public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) { return p1.getKey().equals(p2.getKey()) && p1.getValue().equals(p2.getValue()); } } public class Pair<K, V> { private K key; private V value; public Pair(K key, V value) { this.key = key; this.value = value; } public void setKey(K key) { this.key = key; } public void setValue(V value) { this.value = value; } public K getKey() { return key; } public V getValue() { return value; } }
我们可以这样来调用泛型方法。
Pair<Integer, String> p1 = new Pair<>(1, "apple"); Pair<Integer, String> p2 = new Pair<>(2, "pear"); boolean same = Util.<Integer, String>compare(p1, p2);
以上也就是简单的应用，那我们还会遇到什么情况呢，下面看一看关于通配符的问题，为了演示效果，我写了一个实际用处不大的方法。
public static void printSize(List<Object> list){ System.out.println(list.size()); } public static void main(String[] args) { List<Integer> list1 = new ArrayList<>(); List<String> list2 = new ArrayList<>(); printSize(list1); // 报错 }
上面我们已经知道，在集合中使用泛型可以使程序更加安全，易读，所以 Java 规范推荐我们使用泛型，那我们看一下上面这种情况，我该如何表示接收所有带有泛型的 List 集合呢。上面使用 LIst<Object> 是不行的。为什么不行？我们该使用何种方式接收参数呢？
首先来解释一下为什么不行，先看一下简单的区别。
Object obj = new Integer(1); ArrayList<Object> list = new ArrayList<Integer>(); // 报错
obj 可以赋值成功，是因为多态（往深了说是里氏替换原则），父类的引用指向了子类的实体，而下面的报错了，直观的理由说明，ArrayList<Object> 不是 ArrayList<Integer> 的父类。嗯，确实不是，为什么不是，一句话带过，是因为 Java 中正常的泛型是不变的，当然我们也可以使其改变。（不变，协变和逆变的概念可以自行百度）
传送门：https://www.cnblogs.com/keyi/p/6068921.html
那我就是想让方法接收所有的带泛型的集合该怎么办呢？这时候通配符就出现了，我们可以使用 List<?> 代表所有的带泛型的 List ，这样也就是说可以使用 List<?> 来指向所有的带泛型的 LIst 。
public static void printSize(List<?> list){ System.out.println(list.size()); } public static void main(String[] args) { List<Integer> list1 = new ArrayList<>(); List<String> list2 = new ArrayList<>(); printSize(list1); printSize(list2); }
好的，再次梳理一下逻辑，在 Java 中我们可以使用父类的引用指向子类的对象，而在泛型中，List<Object> 和 List<Integer> 不构成继承关系，原因是因为泛型是不可变的，然而我们又希望表示所有带有泛型的集合，这时就出现了 ？通配符。我们可以使用 List<?> 来引用其它带泛型的 List 。
实际的效果就是这样
List<Object> list1 = new ArrayList<Integer>(); // 报错 List<?> list2 = new ArrayList<Integer>();
那好，现在要求升级了，我希望我的 List 集合不要什么都可以指向，下面就看一下一些有限制条件的修饰符该如何表示。
// 通用修饰符 List<?> list1 = new ArrayList<Integer>(); // <? extends T> 可用于表示 T 以及 T 的子类 List<? extends Number> list2 = new ArrayList<Number>(); List<? extends Number> list3 = new ArrayList<Integer>(); List<? extends Number> list4 = new ArrayList<String>(); // 报错 // <? super T> 可用于表示 T 以及 T 的父类 List<? super Number> list5 = new ArrayList<Number>(); List<? super Number> list6 = new ArrayList<Object>(); List<? super Number> list7 = new ArrayList<Integer>(); //报错
对于上面的 <? extends Number> 和 <? super Number> 该如何选择呢 ？先说结论：” Producer Extends，Consumer Super ” 简称 PECS 原则。
“Producer Extends” – 如果你需要一个只读 List，用它来 produce T，那么使用< ? extends T > 。
“Consumer Super” – 如果你需要一个只写 List，用它来 consume T，那么使用< ? super T > 。
如果需要同时读取以及写入，那么我们就不能使用通配符了。
List<? extends Number> list = new ArrayList<Number>(); List<? extends Number> list = new ArrayList<Integer>(); List<? extends Number> list = new ArrayList<Double>(); // 不论具体的实例化是什么，我们 get 元素之后都是父类 Number // 所以是 produce ，可以 get 得到很多的 T Number number = list.get(0); list.add(new Integer(1)); // 报错
由于以上的三种实例化方式都是允许的，那么假如我现在想从 list 中 get 一个实例，因为 list 指向的实例可能是 Animal ，Dog，或 Cat 实例的集合。所以返回的值会统一为其父类。而在 add 值的时候就会存在问题，我不能确定添加的元素具体是哪一个，除了 null ，所以会报错。
同样的思路再来看< ? super T > 操作。
List<? super Integer> list = new ArrayList<Integer>(); List<? super Integer> list = new ArrayList<Number>(); List<? super Integer> list = new ArrayList<Object>(); // 不同的实例化，我们 get 元素之后返回的值不确定 // 或是 Integer， Number， Object …… list.get(0); // 添加数据的时候可以确定的添加是什么 // 所以 super 对应只写入的情况，即 consume T list.add(new Integer(1));
关于泛型还要说明的是泛型是应用在编译时期的一项技术，而在运行期间是不存在泛型的。原因在于泛型类型擦除。为什么这么说，我们可以来看个示例
public static void main(String[] args) { List<Integer> list = new ArrayList<Integer>(); list.add(456); list.add("123");// 编译报错 } -------------------------------------------------- public static void main(String[] args) { List<String> l1 = new ArrayList<String>(); List<Integer> l2 = new ArrayList<Integer>(); System.out.println(l1.getClass()); System.out.println(l1.getClass().equals(l2.getClass())); } // class java.util.ArrayList // true
究其原因，在于 Java 中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的 class 文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。
在类型擦除之后，若是在代码中有相应的类型变量，遵循 " 保留上界 " 规则，会将相应的 T 替换成具体的类。
< ? > ---- > Object
< ? extends T > ---- > T
< ? super T > ----- > Object
补充说明一点，Java 中不允许直接创建泛型数组。
List<Integer>[] lists = new ArrayList<Integer>(); // 报错 看以下演示代码 // Not really allowed. List<String>[] lsa = new List<String>[10]; //1 Object o = lsa; Object[] oa = (Object[]) o; List<Integer> li = new ArrayList<Integer>(); li.add(new Integer(3)); // Unsound, but passes run time store check oa[1] = li; // Run-time error: ClassCastException. String s = lsa[1].get(0);
如果允许泛型数组的存在（第 1 处代码编译通过），那么在第 2 处代码就会报出 ClassCastException，因为 lsa[1] 是 List<Integer> 。Java 设计者本着首要保证类型安全（type-safety）的原则，不允许泛型数组的存在，使得编译期就可以检查到这类错误。
解决方案
List<?>[] lsa = new List<?>[10]; //1 Object o = lsa; Object[] oa = (Object[]) o; List<Integer> li = new ArrayList<Integer>(); li.add(new Integer(3)); // Correct. oa[1] = li; // Run time error, but cast is explicit. String s = (String) lsa[1].get(0); //2
在第 1 处，用 ? 取代了确定的参数类型。根据通配符的定义以及 Java 类型擦除的保留上界原则，在 2 处 lsa[1].get(0) 取出的将会是 Object，所以需要程序员做一次显式的类型转换。
还有一种通过反射的方式来实现，使用 java.util.reflect.Array，可以不使用通配符，而达到泛型数组的效果。
List<String>[] lsa = (List<String>[])Array.newInstance(ArrayList.class, 4); //1 Object o = lsa; Object[] oa = (Object[]) o; List<Integer> li = new ArrayList<Integer>(); li.add(new Integer(3)); // Correct. oa[1] = li; // Run time error, but cast is explicit. String s = lsa[1].get(0); //2
可以看到，利用 Array.newInstance() 生成了泛型数组，这里没有使用任何通配符，在第 2 处也没有做显式的类型转换，但是在第 1 处，仍然存在显式类型转换。
所以要想使用泛型数组，要求程序员必须执行一次显示的类型转换，也就是将类型检查的问题从编译器交给了程序员。但是呢，泛型的设计初衷就是编译器会帮助我们检查数据类型。你说矛盾不矛盾！
参考资料：
http://www.importnew.com/24029.html
https://blog.csdn.net/sunxianghuang/article/details/51982979
https://www.cnblogs.com/wxw7blog/p/7517343.html
https://www.cnblogs.com/keyi/p/6068921.html
https://blog.csdn.net/yi_Afly/article/details/52058708
