泛型
| 术语 | 中文含义 | 举例 |
|---|---|---|
| Parameterized type | 参数化的类型 | List |
| Actual type | parameter | 实际类型参数String |
| Generic type | 泛型类型 | List |
| Formal type | parameter | 形式类型参数 E |
| Unbounded wildcard type | 无限制通配符类型 | List<?> |
| Raw type | 原始类型 | List |
| Bounded type parameter | 有限制类型参数 | |
| Recursive type bound | 递归类型限制 | <T extends Comparable> |
| Bounded wildcard type | 有限制通配符类型 | List<? extends Number> |
| Generic method | 泛型方法 | static List asList(E[] a) |
| Type token | 类型令牌 | String.class |
不要使用原始类型（如List）
每一种泛型类型都定义一个原生态类型，例如List对应的原生态类型就是List，他们的存在主要是为了与泛型出现之前的代码兼容。
有了泛型之后，类型声明中可以包含信息，而不是通过注释去提醒：
private final Collection<Stamp> stamps = ....
从这个声明中，编译器知道stamps 集合应该只包含Stamp 实例，错误的插入会生成一个编译时错误消息，提醒具体是哪里出错了：
Test.java:9: error: incompatible types: Coin cannot be converted to Stamp
c.add(new Coin());
^
当从集合中检索元素时，编译器会为你插入不可⻅的强制转换
如果使用诸如List 之类的原始类型，则会丢失类型安全性，但是如果使用参数化类型（例如List）则不会
原始类型List逃避了泛型检查，而参数化类型List 明确地告诉编译器，它能够保存任何类型的对象。
可以将List 传递给List 类型的参数，但不能将其传递给List 类型的参数。泛型有子类型化的规则，List 是原始类型 List 的子类型，但不是参数化类型List 的子类型
为了更直观的说明，给出下面的代码：
public static void main(String[] args) {
List<String> strings = new ArrayList<>();
unsafeAdd(strings, Integer.valueOf(42));
String s = strings.get(0); // Has compiler-generated cast
}
private static void unsafeAdd(List list, Object o) {
list.add(o);
}
如果运行该程序，则当程序尝试调用strings.get(0)的结果（一个Integer）转换为一个String 时，会得到ClassCastException 异常。
如果在unsafeAdd的声明中的原始类型List 替换参数化类型List，则编译器直接就会给出报错信息：
在不确定或不在意集合中元素类型时，可能会用到原始类型。例如编写一个返回两个集合中重复元素个数的程序：
static int numElementsInCommon(Set s1, Set s2) {
int result = 0;
for (Object o1 : s1)
if (s2.contains(o1))
result++;
return result;
}
这种方法使用原始类型，是危险的。安全替代方式是使用无限制通配符类型（unbounded wildcard types）。如果要使用泛型类型，但不知道或关心实际类型参数是什么，则可以使用问号来代替。例如，泛型类型 Set 的无限制通配符类型是Set<?>
static int numElementsInCommon(Set<?> s1, Set<?> s2){…}
“不要使用原始类型”这条规则有几个特例情况：
- 必须在类签名（class literals）中使用原始类型
例如List.class，String[].class 和int.class 都是合法的，但List.class 和List<?>.class 不合法
- 因为泛型类型信息在运行时被擦除，所以在<?>以外的参数化类型上使用instanceof是非法的
下面是使用泛型类型的instanceof 运算的示例：
if (o instanceof Set) { // Raw type
Set<?> s = (Set<?>) o; // Wildcard type
...
}
一旦确定 o 对象是一个Set，则必须将其转换为通配符Set<?>。这是一个强制转换，所以不会导致编译器警告。
消除非受检的警告
使用泛型编程时，会看到许多编译器警告：
- 非受检强制转换警告（unchecked cast warning）
- 非受检方法调用警告
- 非受检参数化可变参数类型警告（unchecked parameterized vararg type warning）
- 非受检转换警告（unchecked conversion warning）
有些警告非常难消除，但还是要秉承尽可能消除每一个受检警告的原则，如果不能消除警告，但确信引发警告的代码是类型安全的，那么用@SuppressWarnings(“unchecked”)注解来禁止这条警告。
如果在不止一行的方法或构造函数中使用了@SuppressWarnings(“unchecked”)，可以将它移动到一个局部变量的声明中。
将@SuppressWarnings(“unchecked”)注解放在return语句中是不合法的，因为它不是一个声明，也不要把注解放在整个方法上，而是应该声明一个局部变量来保存返回值，在局部变量上面添加注解：
public <T> T[] toArray(T[] a) {
if (a.length < size) {
// This cast is correct because the array we're creating
// is of the same type as the one passed in, which is T[].
@SuppressWarnings("unchecked")
T[] result = (T[]) Arrays.copyOf(elements, size, a.getClass());
return result;
}
System.arraycopy(elements, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
每当使用@SuppressWarnings(“unchecked”) 注解时，都要写一下注释，说明为什么这么做是安全的
列表优于数组
数组与泛型有很大的不同：
-
数组是协变的（covariant）(如果Sub是Super的子类型，则数组类型Sub[] 是数组类型Super[] 的子类型)
-
泛型是不变的（invariant）
对于任何两种不同的类型Type1 和Type2，List 既不是List 的子类型也不是父类型。
现在有两段代码：
//Throws ArrayStoreException
Object[] objectArray = new Long[1];
objectArray[0] = "I don't fit in";
// Incompatible types
List<Object> ol = new ArrayList<Long>();
ol.add("I don't fit in");
对于上面两种方法无论哪种方式都会报错，因为不能把一个String 类型放到一个Long 类型容器中，但是用一个数组的话，在运行时才会报错；对于列表，可以在编译时就能发现错误。
-
数组是具体化的 （在运行时才知道和强化他们的类型
就比如上面的代码，将String保存到Long数组中就会得到ArrayStoreException异常） -
泛型在编译时就强化它的类型信息，并在运行时擦除它的元素类型信息
》由于上面这些区别，数组和泛型不能很好地混用，所以new List[]，new List，new E[]这些语法都是错误的！在编译时会产生一个泛型数组创建错误。
非法的原因是它不类型安全的
List<String>[] stringLists = new List<String>[1]; // (1)
List<Integer> intList = List.of(42); // (2)
Object[] objects = stringLists; // (3)
objects[0] = intList; // (4)
String s = stringLists[0].get(0); // (5)
- 假设第1行创建一个泛型数组是合法的
- 第2行创建并初始化包含单个元素的List
- 第3行将List 数组存储到Object数组变量中，这是合法的，因为数组是协变的
- 第4行将List 存储在Object数组的唯一元素中，这是因为泛型是通过擦除来实现的：List[] 实例是List[]，所以这个赋值不会产生ArrayStoreException 异常
我们将一个List 实例存储到一个声明为List 实例的数组中，为了防止这种情况出现，第一行必须报错。
E，List 和List 等在技术上被称为不可具体化的类型，指其运行时表示法包含的信息比它的编译时表示法包含的信息更少。唯一可具体化的参数化类型是无限制的通配符类型，如List<?>等，创建无限制通配符类型的数组是合法的，但并不常用。
当泛型数组创建错误时，最佳解决方案是使用集合类型List 。例如编写一个带有集合的Chooser类和一个方法，方法返回集合中随机选择的一个元素。
数组和泛型有着截然不同的类型规则：
- 数组是协变且可以具体化的
- 泛型是不可变的且可以被擦除的
优先考虑泛型
以一个简单的栈类实现为例：
public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;
public Stack(){
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}
public void push(Object e){
ensureCapacity();
elements[size ++] = e;
}
public Object pop(){
if (size == 0)
throw new EmptyStackException();
Object result = elements[-- size];
elements[size] = null;
return result;
}
public boolean isEmpty(){
return size == 0;
}
private void ensureCapacity() {
if (elements.length == size)
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}
//用相应的类型参数替换所有的Object类型：
public class Stack<E> {
private E[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;
public Stack(){
elements = new E[DEFAULT_INITIAL_CAPACITY];
}
public void push(E e){
ensureCapacity();
elements[size ++] = e;
}
public E pop(){
if (size == 0)
throw new EmptyStackException();
E result = elements[-- size];
elements[size] = null;
return result;
}
}
这个类产生一个错误：不能创建一个不可具体化类型E的数组
两个解决方法
- 创建一个Object数组，将它转换成泛型数组类型
这里需要确保unckecked cast不会危及程序的安全性：相关的数组（elements）保存在一个private的域中，永远不会返回给客户端或传递给任何其他方法。
由于构造方法只包含未经检查的数组创建，所以在整个构造方法中抑制警告。
- 将elements的类型从E[] 更改为Object[]
这样会得到一条不同的错误：
可以把从数组中获取到的元素强制转换为E
E result = (E)elements[-- size];
上面两个方法，第一个方法可读性更强：数组被声明为E[ ]类型以清晰地表示它只包含E实例；第一个方法更简洁：第一种方法只需在创建数组的时候转换一次，第二种方法每次读取一个数组元素时都需要转换一次。
优先考虑泛型方法
静态工具方法尤其适合于泛型化
编写泛型方法类似于编写泛型类：
public static Set union(Set s1, Set s2) {
Set result = new HashSet(s1);
result.addAll(s2);
return result;
}
上面的会收到警告可以用
public static <E> Set<E> union(Set<E> s1, Set<E> s2) {
Set<E> result = new HashSet<>(s1);
result.addAll(s2);
return result;
}
使用上面的方法也很简单：
public static void main(String[] args) {
Set<String> guys = CollUtil.newHashSet("Tom", "Dick", "Harry");
Set<String> stooges = CollUtil.newHashSet("Larry", "Moe", "Curly");
Set<String> aflCio = union(guys, stooges);
System.out.println(aflCio);
}
![上面代码的运行结果会输出：[Moe, Tom, Harry, Larry, Curly, Dick]](https://img-blog.csdnimg.cn/d57f37fb444e45b5835477d81205cf25.png)
union 方法的一个限制是所有三个集合（输入参数和返回值）的类型必须完全相同。通过使用限定通配符类型（bounded wildcard types）（Set<? extends xxx>），可以使该方法更加灵活。
除此之外，还有递归类型限制（recursive type bound）的概念：通过包含类型参数本身的表达式来限制类型参数。
递归类型限制的一个经典用法和Comparable接口有关：
public interface Comparable<T> {
int compareTo(T o);
}
类型参数T，可以与实现Comparable 的类型的元素进行比较。例如，String 类实现了Comparable，Integer 类实现了Comparable，几乎所有类型都只能与同类型的元素比较。
public static <E extends Comparable<E>> E max(Collection<E> c);
<E extends Comparable > 可以理解为「任何可以与自己比较的类型E」
下面的代码实现了计算最大值的功能：
public static <E extends Comparable<E>> E max(Collection<E> c) {
if (c.isEmpty())
throw new IllegalArgumentException("Empty collection");
E result = null;
for (E e : c)
if (result == null || [e.compareTo(result](http://e.compareTo(result)) > 0)
result = Objects.requireNonNull(e);
return result;
}
利用限定通配符来提升API的灵活性
public class Stack<E> {
public Stack();
public void push(E e);
public E pop();
public boolean isEmpty();
}
//将多个元素放到栈里：
public void pushAll(Iterable<E> src) {
for (E e : src)
push(e);
}
Java提供了一种特殊的参数化类型——限定通配符类型（bounded wildcard type），pushAll的输入参数类型应该是「E的某个子类型的Iterable接口」，用代码表示就是Iterable<? extends E>：
public void pushAll(Iterable<? extends E> src) {
for (E e : src)
push(e);
}
Collection 不是Collection 的子类型。popAll的输入参数的类型不应该是「E的集合」，而应该是「E的某个父类型的集合」。如下
public void popAll(Collection<? super E> dst) {
while (!isEmpty())
dst.add(pop());
}
为了获得最大的灵活性，对代表生产者和消费者的输入参数使用通配符类型
