28. 列表优于数组

　　数组在两个重要方面与泛型不同。 首先，数组是协变的（covariant）。 这个吓人的单词意味着如果 Sub 是 Super 的子类型，则数组类型 Sub[] 是数组类型 Super[] 的子类型。 相比之下，泛型是不变的（invariant）：对于任何两种不同的类型 Type1 和 Type2，List<Type1> 既不是 List<Type2> 的子类型也不是父类型。[JLS，4.10; Naftalin07, 2.5]。 你可能认为这意味着泛型是不足的，但可以说是数组缺陷。 这段代码是合法的：

  1. // Fails at runtime!
  2. Object[] objectArray = new Long[1];
  3. objectArray[0] = "I don't fit in"; // Throws ArrayStoreException

　　但这个不是：

  1. // Won't compile!
  2. List<Object> ol = new ArrayList<Long>(); // Incompatible types
  3. ol.add("I don't fit in");

　　无论哪种方式，你不能把一个 String 类型放到一个 Long 类型容器中，但是用一个数组，你会发现在运行时产生了一个错误；对于列表，可以在编译时就能发现错误。 当然，你宁愿在编译时找出错误。

　　数组和泛型之间的第二个主要区别是数组被具体化了（reified）[JLS，4.7]。 这意味着数组在运行时知道并强制执行它们的元素类型。 如前所述，如果尝试将一个 String 放入 Long 数组中，得到一个 ArrayStoreException 异常。 相反，泛型通过擦除（erasure）来实现[JLS，4.6]。 这意味着它们只在编译时执行类型约束，并在运行时丢弃（或擦除）它们的元素类型信息。 擦除是允许泛型类型与不使用泛型的遗留代码自由互操作（详见第 26 条），从而确保在 Java 5 中平滑过渡到泛型。

　　由于这些基本差异，数组和泛型不能很好地在一起混合使用。 例如，创建泛型类型的数组，参数化类型的数组，以及类型参数的数组都是非法的。 因此，这些数组创建表达式都不合法：new List<E>[]，new List<String>[]，new E[]。 所有将在编译时导致泛型数组创建错误。

　　为什么创建一个泛型数组是非法的？ 因为它不是类型安全的。 如果这是合法的，编译器生成的强制转换程序在运行时可能会因为 ClassCastException 异常而失败。 这将违反泛型类型系统提供的基本保证。

　　为了具体说明，请考虑下面的代码片段：

  1. // Why generic array creation is illegal - won't compile!
  2. List<String>[] stringLists = new List<String>[1];  // (1)
  3. List<Integer> intList = List.of(42);               // (2)
  4. Object[] objects = stringLists;                    // (3)
  5. objects[0] = intList;                              // (4)
  6. String s = stringLists[0].get(0);                  // (5)

　　让我们假设第 1 行创建一个泛型数组是合法的。第 2 行创建并初始化包含单个元素的 List<Integer>。第 3 行将 List<String> 数组存储到 Object 数组变量中，这是合法的，因为数组是协变的。第 4 行将 List<Integer> 存储在 Object 数组的唯一元素中，这是因为泛型是通过擦除来实现的：List<Integer> 实例的运行时类型仅仅是 List，而 List<String>[] 实例是 List[]，所以这个赋值不会产生 ArrayStoreException 异常。现在我们遇到了麻烦。将一个 List<Integer> 实例存储到一个声明为仅保存 List<String> 实例的数组中。在第 5 行中，我们从这个数组的唯一列表中检索唯一的元素。编译器自动将检索到的元素转换为 String，但它是一个 Integer，所以我们在运行时得到一个 ClassCastException 异常。为了防止发生这种情况，第 1 行（创建一个泛型数组）必须产生一个编译时错误。

　　类型 E，List<E> 和 List<String> 等在技术上被称为不可具体化的类型（nonreifiable types）[JLS，4.7]。 直观地说，不可具体化的类型是其运行时表示包含的信息少于其编译时表示的类型。 由于擦除，可唯一确定的参数化类型是无限定通配符类型，如 List<?> 和 Map<?, ?>（详见第 26 条）。 尽管很少有用，创建无限定通配符类型的数组是合法的。

　　禁止泛型数组的创建可能会很恼人的。 这意味着，例如，泛型集合通常不可能返回其元素类型的数组（但是参见条目 33 中的部分解决方案）。 这也意味着，当使用可变参数方法（详见第 53 条）和泛型时，会产生令人困惑的警告。 这是因为每次调用可变参数方法时，都会创建一个数组来保存可变参数。 如果此数组的元素类型不可确定，则会收到警告。 SafeVarargs 注解可以用来解决这个问题（详见第 32 条）。

　　当你在强制转换为数组类型时，得到泛型数组创建错误，或是未经检查的强制转换警告时，最佳解决方案通常是使用集合类型 List<E> 而不是数组类型 E[]。 这样可能会牺牲一些简洁性或性能，但作为交换，你会获得更好的类型安全性和互操作性。

　　例如，假设你想用带有集合的构造方法来编写一个 Chooser 类，并且有个方法返回随机选择的集合的一个元素。 根据传递给构造方法的集合，可以使用选择器作为游戏模具，魔术 8 球或数据源进行蒙特卡罗模拟。 这是一个没有泛型的简单实现：

  1. // Chooser - a class badly in need of generics!
  2. public class Chooser {
  3.     private final Object[] choiceArray;
  6.     public Chooser(Collection choices) {
  7.         choiceArray = choices.toArray();
  8.     }
  11.     public Object choose() {
  12.         Random rnd = ThreadLocalRandom.current();
  13.         return choiceArray[rnd.nextInt(choiceArray.length)];
  14.     }
  15. }

　　要使用这个类，每次调用方法时，都必须将 Object 的 choose 方法的返回值转换为所需的类型，如果类型错误，则转换在运行时失败。 我们先根据条目 29 的建议，试图修改 Chooser 类，使其成为泛型的。

  1. // A first cut at making Chooser generic - won't compile
  2. public class Chooser<T> {
  3.     private final T[] choiceArray;
  5.     public Chooser(Collection<T> choices) {
  6.         choiceArray = choices.toArray();
  7.     }
  9.     // choose method unchanged
  10. }

　　如果你尝试编译这个类，会得到这个错误信息：

  1. Chooser.java:9: error: incompatible types: Object[] cannot be
  2. converted to T[]
  3.         choiceArray = choices.toArray();
  4.                                      ^
  5.   where T is a type-variable:
  6.     T extends Object declared in class Chooser

　　没什么大不了的，将 Object 数组转换为 T 数组：

  1. choiceArray = (T[]) choices.toArray();

　　这没有了错误，而是得到一个警告：

  1. Chooser.java:9: warning: [unchecked] unchecked cast
  2.         choiceArray = (T[]) choices.toArray();
  3.                                            ^
  4.   required: T[], found: Object[]
  5.   where T is a type-variable:
  6. T extends Object declared in class Chooser

　　编译器告诉你在运行时不能保证强制转换的安全性，因为程序不会知道 T 代表什么类型——记住，元素类型信息在运行时会被泛型删除。 该程序可以正常工作吗？ 是的，但编译器不能证明这一点。 你可以证明这一点，在注释中提出证据，并用注解来抑制警告，但最好是消除警告的原因（详见第 27 条）。

　　要消除未经检查的强制转换警告，请使用列表而不是数组。 下面是另一个版本的 Chooser 类，编译时没有错误或警告：

  1. // List-based Chooser - typesafe
  2. public class Chooser<T> {
  3.     private final List<T> choiceList;
  6.     public Chooser(Collection<T> choices) {
  7.         choiceList = new ArrayList<>(choices);
  8.     }
  11.     public T choose() {
  12.         Random rnd = ThreadLocalRandom.current();
  13.         return choiceList.get(rnd.nextInt(choiceList.size()));
  14.     }
  15. }

　　这个版本有些冗长，也许运行比较慢，但是值得一提的是，在运行时不会得到 ClassCastException 异常。

　　总之，数组和泛型具有非常不同的类型规则。 数组是协变和具体化的; 泛型是不变的，类型擦除的。 因此，数组提供运行时类型的安全性，但不提供编译时类型的安全性，反之亦然。 一般来说，数组和泛型不能很好地混合工作。 如果你发现把它们混合在一起，得到编译时错误或者警告，你的第一个冲动应该是用列表来替换数组。