由于前几章在看的过程中感觉用处不是特别大，且大部分与自己的理解相同，因此不做记录。这一部分主要记录泛型的概念和应用，由于自己对泛型的理解也不是很好，着重记录一下~由于泛型内容有点多，分成上下两部分。
相关概念术语
首先什么是泛型呢。
声明中具有一个或多个类型参数的类或接口就是泛型类或泛型接口。例如，
List接口有一个类型参数E，用于表示其元素类型。该接口的全名是List<E>（读作「List of E」），但人们通常简称为 List。泛型类和泛型接口统称为泛型。
每个泛型定义了一组参数化类型，这些参数化类型包括类名或接口名 + 带尖括号的参数列表。 例如List<String>，List是接口名， String是参数列表中的元素。最后，每个泛型都定义了一个原始类型，它是没有任何相关类型参数的泛型的名称。例如List（这种被称作原始类型）。这种定义主要是为了与之前的泛型代码兼容。
不要使用原始类型
原始类型 vs 泛型
由于泛型是在Java 1.5才加入的，在1.5之前，java声明集合的方式如下：
private final Collection stamps = ... ;
在1.5之后，使用这种声明并调用，会出发警告, 且从集合中取出元素需要进行强转，这里容易出现 ClassCastException
stamps.add(new Coin( ... )); // 触发 "unchecked call" warning
OtherObject stamp = (OtherObject) stamps.get(0); // 在运行时抛出 ClassCastException
当声明泛型后，编译器会对集合中的元素进行检查，在编译时就能报错。当取出元素时，会触发自动类型转换。我们希望越早发现错误越好，最好在编写代码时发现问题，不希望在最终运行时抛出异常
这里有一个问题， 原始类型List可以放入任意对象，List<Object>同样可以放入任意对象，那么这两者的区别在哪里呢？
粗略地说，前者选择了不使用泛型系统，而后者明确地告诉编译器它能够保存任何类型的对象。虽然可以将
List<String>传递给List类型的参数，但不能将其传递给类型List<Object>的参数。泛型有子类型规则，List<String>是原始类型List的子类型，而不是参数化类型List<Object>的子类型。因此，如果使用原始类型（如 List），就会失去类型安全性，但如果使用参数化类型（如 List<Object>）则不会。
实际应用
当我们想编写一个方法，该方法接受两个集合并返回它们共有的元素数量，Set 作为参数，作为新手可能这样写
//注意这里使用了原始类型，这样很危险
static int numElementsInCommon(Set s1, Set s2) {
int result = 0;
for (Object o1 : s1)
if (s2.contains(o1))
result++;
return result;
书中给出的替代方法是使用无界通配符类型，即Set<?>代替Set，这样做的好处是可以保证集合类型的一致性（保证集合内元素的类型唯一）
当然对于不应该使用原始类型的规则，有一些小的例外：
-
必须在类字面量中使用原始类型，例如
List.class是合法的，但List<String>.class``List<?>.class是非法的 -
instanceof运算符的应用。 由于泛型信息在运行时被删除，因此在不是无界通配符类型之外的参数化类型上使用 instanceof 操作符是非法的。
//一旦确定 o 是一个 Set，就必须将其强制转换为通配符类型 Set<?>，而不是原始类型 Set。这是一个经过检查的强制类型转换，所以不会引发编译器警告
if (o instanceof Set) { // Raw type
Set<?> s = (Set<?>) o; // Wildcard type
...
}
消除 unchecked 警告
使用泛型编程时，总会看到许多编译器警告：
- unchecked cast warnings
- unchecked method invocation warnings
- unchecked parameterized vararg type warnings
- unchecked conversion warnings
我们可以通过消除以上的unchecked warnings来保证泛型的安全性
//这样声明会给出unchecked警告
Set<Lark> exaltation = new HashSet();
//一般IDE 或编译器会给出如下的修改建议
Set<Lark> exaltation = new HashSet<>();
但是由于历史原因或其他原因，如果不能消除警告，但是可以证明引发警告的代码是类型安全的，那么（并且只有在那时）使用 SuppressWarnings("unchecked") 注解来抑制警告。@SuppressWarnings("unchecked")可以用于单个局部变量声明乃至整个类，但是总是在尽可能小的范围上使用 SuppressWarnings 注解， 同时每次使用 SuppressWarnings("unchecked") 注解时，要添加一条注释，说明这样做是安全的。
总之，unchecked 警告很重要。不要忽视他们。每个 unchecked 警告都代表了在运行时发生 ClassCastException 的可能性。尽最大努力消除这些警告。如果不能消除 unchecked 警告，并且可以证明引发该警告的代码是类型安全的，那么可以在尽可能狭窄的范围内使用 @SuppressWarnings("unchecked") 注释来禁止警告。在注释中记录你决定隐藏警告的理由。
List 使用优于数组
数组与泛型的区别：
- 数组是协变的
- 数组是具体化的
由于这两个差异，数组和泛型不能很好地混合。例如，创建泛型、参数化类型或类型参数的数组是非法的。 即new List<E>[]、new List<String>[]、new E[]均不合法。
数组是协变的
如果type2 是 type1的子类型，那么下面一段代码是合法的
// Long 是 object的子类型，代码合法，但是会在运行时抛出异常
Object[] objectArray = new Long[1];
objectArray[0] = "I don't fit in"; // Throws ArrayStoreException
对于List 则没有上述问题
//编译时报错
List<Object> ol = new ArrayList<Long>(); // Incompatible types
ol.add("I don't fit in");
数组是具体化的
数组在运行时知道并强制执行他们的元素类型，如果试图将 String 元素放入一个 Long 类型的数组中，就在运行时会得到 ArrayStoreException；泛型是通过擦除来实现的，只在编译时进行约束，运行时丢弃（或擦除）元素类型信息。
当在转换为数组类型时遇到泛型数组创建错误或 unchecked 强制转换警告时，通常最好的解决方案是使用集合类型 List<E>，而不是数组类型 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()后，都需要将结果进行一次强制转换，且很容易在运行时抛出异常。因此这里改为使用泛型
public class Chooser<T> {
private final T[] choiceArray;
public Chooser(Collection<T> choices) {
//此处会编译报错
choiceArray = choices.toArray();
}
public Object choose() {
Random rnd = ThreadLocalRandom.current();
return choiceArray[rnd.nextInt(choiceArray.length)];
}
}
然而在编译时报错
Chooser.java:9: error: incompatible types: Object[] cannot be converted to T[]
choiceArray = choices.toArray();
^ where T is a type-variable:
T extends Object declared in class Chooser
到这也许会简单粗暴的把choiceArray = choices.toArray(); 变为 choiceArray = (T[]) choices.toArray();，进行强制转换。虽然这样解决了错误，但是又会派生一个警告：
# 强转可能会出现问题，不能保证在运行时转换的安全性，因为程序不知道类型 T 代表什么
[unchecked] unchecked cast choiceArray = (T[]) choices.toArray();
^ required: T[], found: Object[]
注意： 虽然Chooser使用了泛型，在运行时元素类型会被抹去，但这样是仍然不安全的。
最终无错误无警告的版本：
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()));
}
}
总之数组和泛型有非常不同的类型规则。数组是协变的、具体化的；泛型是不变的和可被擦除的。因此，数组提供了运行时类型安全，而不是编译时类型安全，对于泛型反之亦然。一般来说，数组和泛型不能很好地混合。如果你发现将它们混合在一起并得到编译时错误或警告，那么你的第一个反应该是将数组替换为 list。
