26 不要使用原始类型（如List）
每一种泛型类型都定义一个原生态类型，例如List<String>对应的原生态类型就是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<String> 传递给List 类型的参数，但不能将其传递给List<Object> 类型的参数。泛型有子类型化的规则，List<String> 是原始类型 List 的子类型，但不是参数化类型List<Object> 的子类型
为了更直观的说明，给出下面的代码：
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<E> 的无限制通配符类型是Set<?>
static int numElementsInCommon(Set<?> s1, Set<?> s2){...}
注意：不能把任何元素（除null之外）放入一个Collection<?> 中，编译器也会报错：
“不要使用原始类型”这条规则有几个特例情况：
1. 必须在类签名（class literals）中使用原始类型
例如List.class，String[].class 和int.class 都是合法的，但List<String>.class 和List<?>.class 不合法
2. 因为泛型类型信息在运行时被擦除，所以在<?>以外的参数化类型上使用instanceof是非法的
下面是使用泛型类型的instanceof 运算的示例：
if (o instanceof Set) { // Raw type Set<?> s = (Set<?>) o; // Wildcard type ... }
一旦确定 o 对象是一个Set，则必须将其转换为通配符Set<?>。这是一个强制转换，所以不会导致编译器警告。
27 消除非受检的警告
这一条告诉我们如何处理非受检的警告。
使用泛型编程时，会看到许多编译器警告：
unchecked cast warning，非受检强制转换警告
非受检方法调用警告
unchecked parameterized vararg type warning，非受检参数化可变参数类型警告
unchecked conversion warning，非受检转换警告
很多非受检警告很容易消除，例如：
Set<Lark> exaltation = new HashSet();
编译器会提醒做错了什么：
根据编译器提示修改：
Set<Lark> exaltation = new HashSet<>();
有些警告非常难消除，但还是要秉承尽可能消除每一个受检警告的原则，如果不能消除警告，但确信引发警告的代码是类型安全的，那么用@SuppressWarnings(“unchecked”)注解来禁止这条警告。
如果在不止一行的方法或构造函数中使用了@SuppressWarnings(“unchecked”)，可以将它移动到一个局部变量的声明中。
例如ArrayList的toArray方法：
public <T> T[] toArray(T[] a) { if (a.length < size) // Make a new array of a's runtime type, but my contents: return (T[]) Arrays.copyOf(elementData, size, a.getClass()); System.arraycopy(elementData, 0, a, 0, size); if (a.length > size) a[size] = null; return a; }
编译器会有这样一条警告：
ArrayList.java:305: warning: [unchecked] unchecked cast return (T[]) Arrays.copyOf(elements, size, a.getClass()); required: T[] found: Object[]
将@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”) 注解时，都要写一下注释，说明为什么这么做是安全的。
28 列表优于数组
数组与泛型有很大的不同：
1. 数组是协变的（covariant）
意思是：如果Sub是Super的子类型，则数组类型Sub[] 是数组类型Super[] 的子类型。
2. 泛型是不变的（invariant）
对于任何两种不同的类型Type1 和Type2，List<Type1> 既不是List<Type2> 的子类型也不是父类型。
现在有两段代码：
Object[] objectArray = new Long[1]; objectArray[0] = "I don't fit in";
List<Object> ol = new ArrayList<Long>(); // Incompatible types ol.add("I don't fit in");
无论哪种方式都会报错，因为不能把一个String 类型放到一个Long 类型容器中，但是用一个数组的话，在运
行时才会报错；对于列表，可以在编译时就能发现错误。
3. 数组是具体化的，在运行时才知道和强化他们的类型
就比如上面的代码，将String保存到Long数组中就会得到ArrayStoreException异常
4. 泛型在编译时就强化它的类型信息，并在运行时擦除它的元素类型信息
由于上面这些区别，数组和泛型不能很好地混用，所以new List<E>[]，new List<String>，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<Integer>
第3行将List<String> 数组存储到Object数组变量中，这是合法的，因为数组是协变的
第4行将List<Integer> 存储在Object数组的唯一元素中，这是因为泛型是通过擦除来实现的：List<String>[] 实例是List[]，所以这个赋值不会产生ArrayStoreException 异常
现在问题就来了，我们将一个List<Integer> 实例存储到一个声明为List<String> 实例的数组中，为了防止这种情况出现，第一行必须报错。
E，List<E> 和List<String> 等在技术上被称为不可具体化的类型，指其运行时表示法包含的信息比它的编译时表示法包含的信息更少。唯一可具体化的参数化类型是无限制的通配符类型，如List<?>等，创建无限制通配符类型的数组是合法的，但并不常用。
当泛型数组创建错误时，最佳解决方案是使用集合类型List<E> 。例如编写一个带有集合的Chooser类和一个方法，方法返回集合中随机选择的一个元素。
public class Chooser { private final Object[] choiceArray; public Chooser(Collection choices) { choiceArray = choices.toArray(); } public Object choose() { Random rnd = ThreadLocalRandom.current(); return choiceArray[rnd.nextInt(choiceArray.length)]; } }
上面这种写法必须将choose方法的返回值从Object转换成每次调用该方法时想要的类型
public class Chooser<T> { private final T[] choiceArray; public Chooser(Collection<T> choices) { choiceArray = choices.toArray(); } // choose 方法不变 }
上面的类会报错：
如果加一条强制类型转换的话：
choiceArray = (T[]) choices.toArray();
仍有报警信息：
要消除上面的警告，需要用列表代替数组：
public class Chooser<T> { private final List<T> choiceList; public Chooser(Collection<T> choices) { choiceList = new ArrayList<>(choices); } public T choose() { Random rnd = ThreadLocalRandom.current(); return choiceList.get(rnd.nextInt(choiceList.size())); } }
总结一下，数组和泛型有着截然不同的类型规则：
1. 数组是协变且可以具体化的
2. 泛型是不可变的且可以被擦除的
29 优先考虑泛型
每个程序员都应该学习如何编写泛型
以一个简单的栈类实现为例：
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; } // 其他的不变 }
这个类产生一个错误：
如条目28所述，你不能创建一个不可具体化类型E的数组。解决这个问题一般有两个方法：
1. 创建一个Object数组，将它转换成泛型数组类型
这里需要确保unckecked cast不会危及程序的安全性：相关的数组（elements）保存在一个private的域中，永远不会返回给客户端或传递给任何其他方法。
由于构造方法只包含未经检查的数组创建，所以在整个构造方法中抑制警告。
2. 将elements的类型从E[] 更改为Object[]
这样会得到一条不同的错误：
可以把从数组中获取到的元素强制转换为E，这样就得到了一条警告：
根据第27条，只在这个局部上抑制警告，而不是在整个pop方法上：
上面两个方法，第一个方法可读性更强：数组被声明为E[ ]类型以清晰地表示它只包含E实例；第一个方法更简洁：第一种方法只需在创建数组的时候转换一次，第二种方法每次读取一个数组元素时都需要转换一次。
Stack类的具体用法如下，下列代码以倒叙形式打印出命令行参数：
public static void main(String[] args) { Stack<String> stack = new Stack<>(); for (String arg : args){ stack.push(arg); } while (!stack.isEmpty()) System.out.println(stack.pop().toUpperCase()); }
有一些泛型限制了可允许的类型参数值，例如：
class DelayQueue<E extends Delayed> implements BlockingQueue<E>
要求实际的类型参数E 是java.util.concurrent.Delayed的子类型
