Java泛型

Item 26 不要使用原始类型

原始类型的问题在于类型不确定，在编译阶段看不出来问题，而将隐患拖到运行时

//一个 原始类型集合，对集合的元素类型没有约束
private final Collection stamps = ... ;
//往邮票集合添加硬币，编译器会警告但不报错
stamps.add(new Coin( ... ));
//当程序运行到这里时
for (Iterator i = stamps.iterator(); i.hasNext(); )
   //如果放入了非Stamp对象，这里就会类型转化异常
   Stamp stamp = (Stamp) i.next(); 

开发的一个重要守则就是尽早发现问题排除隐患，能在编译时排查的问题就不要拖到运行时，使用泛型可以有效的在编译阶段排查错误，避免运行时类型转化错误

//参数化的集合，指定集合元素必须时Stamp类型
private final Collection<Stamp> stamps = ... ;
//编译错误，在编译阶段明确告诉你类型转化异常
//stamps.add(new Coin( ... ));
stamps.add(new Stamp());
for (Iterator<Stamp> i = stamps.iterator(); i.hasNext(); )
  //编译器做了隐式转化，因为确定元素是Stamp类型，所以不会有转化错误
  Stamp stamp =  i.next(); 

Java为了和之前没有泛型时代的代码兼容，编译的时候泛型信息会被擦除，在取出元素的时候会隐式的帮你做类型转换，正是有参数类型限制，这种转化可以确保是安全的。

那原始类型的集合和参数类型为Object的有什么区别，比如List和List<Object>,它们都可以插入任意对象，但却是有区别的，前者逃避泛型检查，而后者是明确参数类型为Object。指定参数类型的List，如List<String>是List的子类型却不是List<Object>的子类型，看下面的示例

public static void main(String[] args) {
  List<String> strings = new ArrayList<>(); 
  unsafeAdd(strings, Integer.valueOf(42));
  //编译报错
  safeAdd(strings, Integer.valueOf(42));
  String s = strings.get(0); 
}
//由于List<String>是List的子类型，这里编译不会报错，只会警告，但类型却是不安全的，因为原始类型逃避泛型检查
private static void unsafeAdd(List list, Object o) {
   list.add(o);
}
//List元素必须是Object类型，否则编译报错
private static void safeAdd(List<Object> list, Object o) {
   list.add(o);
}

如果参数类型不重要，使用原始类型作为形参确实很方便，没有约束，但有很大隐患，实际开发中有一个更安全的替代方案：无上限通配符，使用这种参数类型的集合，除了Null你不能添加任何元素，也取不出来任何元素

public static void main(String[] args) {
        Set<String> s1 = new HashSet<>();
        s1.add("one");
        Set<Integer> s2 = new HashSet<>();
        s2.add(12);
        int result = cacl(s1, s2);
        System.out.println(result);
    }
        //不在乎Set集合元素的类型，但有需要类型安全
    private static int cacl(Set<?> s1, Set<?> s2) {
        int count = 0;
        for (Object object : s2) {
            if (s1.contains(object)) {
                count++;
            }
        }
        return count;
    }

但有些例外，必须使用原始类型，一个就是类字面量

//合法
List.class, String[].class, and int.class
//不合法
List<String>.class and List<?>.class

另外一个就是instancof类型检查,因为泛型类型在运行时被擦除，所以除了无上限通配符参数类型外，其它参数类型使用instanceof都不合法，但这个无上限的通配符用上显得多余，所以使用instanceof判断就直接使用原始类型了，下面是推荐写法

if (o instanceof Set) {
//必须使用<?>,说明是受检的转换，不会编译警告
  Set<?> s = (Set<?>) o; 
}

Item 27 消除非受检警告

尽可能消除编译阶段提示的每个未受检警告，这样可以极大的提高代码运行时的安全。有些时候实现没有办法消除未受检的警告，但你又确定代码是类型安全的，这种情况下可以使用@SuppressWarnings("unchecked")注解明确告诉编译器这个地方不需要警告，但这个注解的使用要注意两点

• 只有在你确定代码是类型安全的才使用，如果滥用只让编译的结果好看一点，但会隐藏问题给运行时埋下隐患
• 尽量精确的覆盖作用范围，粒度要小，能用在本地变量上就不要用在方法上，能用在方法上就不要用在类上，使用的地方需要给出注释说明理由

以ArrayList的toArray一个方法为例,这是来自Android SDK的源码，@SuppressWarnings("unchecked")直接作用在方法上，而且没有说明理由，其实你是看不出来这个注解对 Arrays.copyOf还是 System.arraycopy起作用或者两个方法都需要，如果以后里面添加一个类型不安全的方法，也会被抑制掩盖

@SuppressWarnings("unchecked")
    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;
    }

所以作者推荐的做法是这样的，因为return语句不能使用注解，为了让这个注解的作用范围更加精确，声明了本地变量result让这个注解作用其上，同时需要说明理由，这样代码的维护就更加明朗和安全。

  public <T> T[] toArray(T[] a) {
        if (a.length < size) {
            //这个转换是安全的，因为数组和我们的参数类型都是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")注解，并添加注释说明理由

Item28列表优先于数组

为啥优先选择列表呢？因为列表能比数组更早的发现风险，这要从数组不同于列表的两个关键点说起
数组是协变类型(Covariant)，意指如果Child是Parent的子类型，那么Child[]也是Parent[]的子类型，但泛型是不变的，List<Child>和List<Parent>没有类型关系。数组的协变特征会埋下隐患

//因为数组是协变类型，这个编译是没问题的，却也掩盖了问题
Object[] objectArray = new Long[1];
//运行时抛异常ArrayStoreException
objectArray[0] = "I don't fit in"; 

数组是具体的(reified)，数组在运行时是知道元素类型的，而泛型仅在编译时限制元素类型，运行时元素类型会被擦除，这是为了和Java5之前的版本兼容。

正是由于这两点，泛型和数组无法配合使用，new List<E>[], new List<String>[], new E[]这些表达式都是不合法的，因为泛型数组类型不安全，下面通过反证法说明泛型数组是不应该合法的，如果合法那么泛型的安全机制都荡然无存

//首先假如泛型数组是合法的，下面这个数组元素类型是List<String>
List<String>[] stringLists = new List<String>[1]; 
//又创建一个列表，类型是List<Integer>
List<Integer> intList = List.of(42);
//因为数组是协变类型，List<String>是子Object类型，所以List<String>[]也是Object[]的子类型
Object[] objects = stringLists;
//因为泛型擦除，运行时List<String>[]变成List[]，list<Integer>变成list，所以这里不会抛ArrayStoreException异常
objects[0] = intList;
//但最后编译器想把取出的元素转化成String，实际取出的元素是Integer，于是就会抛ClassCastException
String s = stringLists[0].get(0);

技术上来说，像E、E[]、List<E>这样的类型都是非具体化的，通俗讲就是运行时的信息表达要比编译时少，参数化类型唯一可具体化的是无上限通配符，如 List<?> and Map<?,?>，极少用到但却是合法的。下面代码编译运行都是成功的

//可创建无上限通配符类型的数组
ArrayList<?>[] listArray = new ArrayList<?>[10];
ArrayList<String> strings = new ArrayList<>();
strings.add("abc");
listArray[0] = strings;

ArrayList<Integer> integers = new ArrayList<>();
 integers.add(10);
listArray[1] =integers;
//参数类型为无上限通配符的List<?>既不能添加元素也不能取出，但可以移除、比较
System.out.println(listArray[0].remove("abc"));//true
System.out.println(listArray[1].contains(10));//true

因为可变参数本质也是数组，所以它和泛型也配合不好，有令人不解的警告，可以使用SafeVarargs注解解决这个问题。如果在使用泛型数组时出现错误或警告，最好使用泛型列表替代。下面的代码使用的就是泛型数组，虽然我们确信转换是安全的，也可以通过注解让警告消失，但如果没有警告会更好

public class Chooser<T> {
    private final T[] choiceArray;
    //参数类型都是T，是安全的
    @SuppressWarnings("unchecked")
    public Chooser(Collection<T> choices) {
        choiceArray = (T[]) choices.toArray();
    }
// choose method unchanged}

下面使用泛型列表实现，虽然性能不及数组，但没有任何警告和错误，类型是安全的

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())); 
    } 
}

数组和泛型区别小结如下，如果数组和泛型混用有问题，优先使用列表

数组	泛型
协变的，可具体化的	不变的，类型可擦除的
运行时类型安全，编译时类型不安全	编译时类型安全，运行时类型不安全

Item29首选泛型

在Item28中建议当遇到数组与列表时，优先考虑使用列表，但Java并不先天性的支持列表，Java列表是基于数组实现的，如ArrayList，这个时候就必须借助数组。下面是个简单的演示

public class Stack<E> {
    private E[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    //elements 是私有的，引用没有外泄，包含元素只有push方法的E，所以确定是类型安全的
    @SuppressWarnings("unchecked")
    public Stack() {
        elements = (E[]) new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(E e) {
        elements[size++] = e;
    }

    public E pop() {
        if (size == 0)
            throw new EmptyStackException();
        E result = elements[--size];
        elements[size] = null; 
        return result;
    }
}

上面这个泛型的实现还是很简洁的，只需要做一次类型转换，但缺点是有堆污染，也就是数组的编译时类型和运行时类型不一样，除非E是Object类型,即使这种情况下堆污染是无害的，也有些令人不爽，但我们还有下面的方案：使用Object数组，对取出的元素内部转换，而不是让客户端去做类型转换，这也是ArrayList的做法。

public class Stack<E> {
    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(E e) {
        elements[size++] = e;
    }

    public E pop() {
        if (size == 0)
            throw new EmptyStackException();
        //push时的元素只能是E，所以这里是类型安全的
        @SuppressWarnings("unchecked")
        E result = (E) elements[--size];
        elements[size] = null;
        return result;
    }
}

上面泛型的参数类型只要是引用就是合法的，有些场景我们需要对参数类型进行限制，也就是有限制的类型参数，如下

public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
   implements BlockingQueue<E> {

E extends Delayed说明参数类型必须是Delayed的子类，这样客户端在使用Delayed方法时就不需要冒险强转。泛型比那些需要在客户端做转换的类型要简单和安全，如有可能尽量泛型化。

Item 30 首选泛型方法

和类一样，方法也可以从泛型中获得同样的好处，尤其是静态工具方法,一个简单的静态泛型方法如下，特殊的地方在于修饰符static和返回值Set<E> 之间需要有类型参数<E>，这个泛型方法的两个输入参数和返回参数类型是一样的，如果使用有限制的通配符会更加灵活，这个下一节说明。

public static <E> Set<E> union(Set<E> s1, Set<E> s2) {
  Set<E> result = new HashSet<>(s1); 
  result.addAll(s2);
  return result;
}

书中介绍的常用于函数的泛型单列工厂模式，没看出来有什么用途，暂时跳过。

 // Generic singleton factory pattern
private static UnaryOperator<Object> IDENTITY_FN = (t) -> t;
   @SuppressWarnings("unchecked")

public static <T> UnaryOperator<T> identityFunction() { 
  return (UnaryOperator<T>) IDENTITY_FN;
}

在深入理解 Java Object一文中介绍的比较两个对象是否相等的equals方法，就会发现使用的不是泛型，实现比较的代码就比较冗长且模版化

PhoneNumber.java
@Override
    public boolean equals(Object o) {
        //判断引用是否相等
        if (o == this) {
            return true;
        }
        if (!(o instanceof PhoneNumber)) {
            return false;
        }
      
      PhoneNumber pNum = (PhoneNumber) o;

   ...

而对象如果要比较排序的话，通常需要实现下面这个泛型接口

public interface Comparable<T> {
       int compareTo(T o);
}

类型参数T限制了需要比较的对象的类型，因为绝大部分比较都是在同类型之间进行,这个方法的复写就比equals简洁的多

PhoneNumber.java
public class PhoneNumber implements Comparable<PhoneNumber> {
@Override
    public int compareTo(PhoneNumber phoneNumber) {
        int result = Short.compare(areaCode, phoneNumber.areaCode);
        if (result == 0) {
            result = Short.compare(prefix, phoneNumber.prefix);
            if (result == 0) {
                result = Short.compare(linNum, phoneNumber.linNum);
            }
        }
        return result;
    }
}

Comparable<T>接口出现在泛型方法中通常都伴随着一个令人头疼的名字：递归类型限制，如下所示的<E extends Comparable<E>>

public static <E extends Comparable<E>> E max(Collection<E> c);

类型限制<E extends Comparable<E>>可以读作针对可以与自身进行比较的每个类型E，也就是列表中的每个元素E都是可以互相比较的。

总之，泛型方法和泛型一样，不需要转化参数就能使用，这样更加安全简洁，所以尽可能将方法泛型化。

Item 31 使用有限制通配符提升API的灵活性

在Item 28中提到过：参数化类型是不可变的。比如Integer是Number的子类，但List<Integer>并不是List<Number>的子类，导致下面的例子编译不通过，这种无限制的类型参数降低了代码的灵活性

public class Test {
    public static void main(String[] args) {
        List<Integer> integers=new ArrayList<>(10);
        integers.add(2);
        //print(integers);编译不通过
    }
    public static void print(List<Number> number){
        System.out.println(number.toString());  
    }

}

还好Java提供了一种有限制的通配符类型解决这类问题，我们对print方法作如下修改，这时输入参数的含义就不是Number的集合，而是Number的某个子类的集合(包括Number自己)。但示例仅仅说明有限制的通配符类型，并没有涉及泛型

public class Test {
    public static void main(String[] args) {
        List<Integer> integers=new ArrayList<>(10);
        integers.add(2);
        print(integers);
    }
        //使用有限制的通配符类型
    public static void print(List<? extends Number> number){
        System.out.println(number.toString());  
    }

}

在Item 29我们有个泛型类Stack

public class Stack<E> {
       public Stack();
       public void push(E e);
       public E pop();
       public boolean isEmpty();
}

如果我们添加一个方法addAll，按照之前的思路会是下面这个样子

public void pushAll(Iterable<E> src) {
      for (E e : src)
       push(e);
}

如果一个名为Obj的对象是E的子类，调用push(Obj)没有问题，但如前文所述，调用pushAll(Iterable<Obj>)就不行，解决方案就是改成下面这个样子

public void pushAll(Iterable<? extends E> src) {
       for (E e : src)
           push(e);
}

如果再添加一个方法，把Stack所有元素弹出到某个集合中，根据经验应该写成这样，其实这样编译不通过的，Java中父类引用可以指向子类对象，但反过来不行，下面就犯了这个错误，dst中的引用是E的子类类型，pop返回的是E，就好像往List<Integer>添加Nubmer，所以无法添加

public void popAll(Collection<? extends E> dst) {
           while (!isEmpty())
           dst.add(pop());
}

知道错误在哪就好办了，只要 限定dst中元素引用是E的父类类型即可，只要把extends改成super即可

public void popAll(Collection<? super E> dst) {
   while (!isEmpty()) dst.add(pop());
}

关于使用extends还是super有一个口诀

• 如果输入参数是生产者，如addAll的参数，使用extends
• 如果是消费者，如popAll的参数，使用super

在上一节有这样一个泛型方法，之前也提到了这种输入参数和返回参数类型都一致的泛型不够灵活，只能是同一种类型

public static <E> Set<E> union(Set<E> s1, Set<E> s2) {
  Set<E> result = new HashSet<>(s1); 
  result.addAll(s2);
  return result;
}

这个方法如果想把Integer类型和Double类型合并就做不到，所以需要使用有限制的通配符类型，两个参数都是生产者，修改如下，注意返回参数类型没变

public static <E> Set<E> union(Set<? extends E> s1, Set<? extends E> s2) {
  Set<E> result = new HashSet<>(s1); 
  result.addAll(s2);
  return result;
}

这种带泛型的有限通配符类型方法使用起来就更加灵活

public static void main(String[] args) {
       //Set没有of这个方法，编译是不通过的，为了演示简洁
       Set<Integer> integers = Set.of(1, 3, 5);
       Set<Double> doubles = Set.of(2.0, 4.0, 6.0); 
       //Java 8可以推导出E的类型为Number
       Set<Number> numbers = union(integers, doubles);
       //Java 8 之前无法推导出，需要使用显示的类型参数
       // Set<Number> numbers2 = Test.<NUmber>union(integers, doubles);
       
   }

现在回头看Item 30的max方法，发现也有优化空间

• 参数c是生产者，从Collection<E>改成Collection<？ extends E>
• Comparable始终是消费者，Comparable<? super E>优于Comparable<E>

//优化前
public static <E extends Comparable<E>> E max(Collection<E> c);
//优化后
public static <E extends Comparable<? super E>> E max(Collection<? extends E> c);

举个例子说明这样优化的好处,下面代码来自JDK。Delayed接口继承了Comparable接口，类型参数为Delayed

public interface Delayed extends Comparable<Delayed> {
    long getDelay(TimeUnit unit);
}

ScheduledFuture又继承了Delayed接口，所以间接的继承了Comparable接口，但是Comparable的类型参数不是ScheduledFuture，而是父类Delayed

public interface ScheduledFuture<V> extends Delayed, Future<V> {
}

所以下面这个集合就不能传入优化前的max方法

List<ScheduledFuture<?>> scheduledFutures = ... ;

因为ScheduledFuture没有 extends Comparable< ScheduledFuture >，而是extends Comparable<Delayed >，Delayed是Comparable的父类。但优化后的max就可以，因为Comparable的类型参数声明为E，也就是这里的ScheduledFuture的父类。

关于类型参数和通配符还有一些值得讨论，比如下面两个交换元素的静态方法，如果类型参数只在方法中出现一次，就可以用通配符替换

//使用类型参数实现
public static <E> void swap(List<E> list, int i, int j);
//使用通配符实现，更简单
 public static void swap(List<?> list, int i, int j);

虽然推荐第二种方法，但List<?>有一个问题，就是除了Null，不能添加其它元素，好在我们有一个辅助方法弥补这个缺陷

public static void swap(List<?> list, int i, int j) {
       swapHelper(list, i, j);
}
   //使用私有的方法捕获通配符类型
private static <E> void swapHelper(List<E> list, int i, int j) { 
  list.set(i, list.set(j, list.get(i)));
}

总的来说使用通配符让API更加灵活，基本原则就是

• 生产者使用extends
• 消费者使用super，所有的comparables 和 comparators 都是消费者

Item 32 谨慎结合泛型和可变参数

可变参数可以极大的方便方法的调用，它允许给一个方法传递可变数量的参数，如下所示

public static void main(String[] args) {
        show("one","two");
        show("one","two","three");
}

public static  void show(String... msgs) {
        for (String string : msgs) {
            System.out.println(string);
        }
}

但这样你可能还不满足，参数String是具体类型，如果改成下面这样的泛型参数岂不更妙，

public static void main(String[] args) {
       show("one","two");
       show(1,3,4);
       show(1.2f,3,4f);
}

public static <T>  void show(T... msgs) {
       for (T string : msgs) {
           System.out.println(string);
       }
}

虽然运行是没问题的，但有些智能编辑器会警告你：msgs这个可变参数会导致堆污染。可变参数是这样实现的，当调用方法时，创建数组来保存可变长的参数，泛型在编译的时候被擦除，所以所以T... msgs就变成了Object[]，但在运行的时候，这个应用指向的类型可能是String[]、Interger[]等，也就是编译时类型和运行时类型不匹配导致的堆污染，容易出现类型转换异常。看下面这个示例。

static void dangerous(List<String>... stringLists) {
      List<Integer> intList = List.of(42);
      //stringLists=List<String>[],数组时协变类型，没有问题
      Object[] objects = stringLists;
      //object[0]的引用是参数化类型List<String>,指向了参数化类型对象List<Integer>，导致堆污染
      objects[0] = intList;
     // 虽然没有显式的cast，但会报ClassCastException
      String s = stringLists[0].get(0);
}

在Item 28里说过像new E[],new List<String>[]这样的显式的泛型数组或参数化类型数组是不合法的，但可变参数却可以隐式的使用它们，这是因为泛型和参数化类型的数组在实际开发中实在太好用了，就破例允许这种不一致的存在，下面是JDK一些源码示例。

Arrays.java
    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        //注意：此处ArrayList为Arrays的私有静态内部类
        return new ArrayList<>(a);
    }

Collections.java
    @SafeVarargs
    public static <T> boolean addAll(Collection<? super T> c, T... elements) {
        boolean result = false;
        for (T element : elements)
            result |= c.add(element);
        return result;
    }

EnumSet.java
@SafeVarargs
    public static <E extends Enum<E>> EnumSet<E> of(E first, E... rest) {
        EnumSet<E> result = noneOf(first.getDeclaringClass());
        result.add(first);
        for (E e : rest)
            result.add(e);
        return result;
    }

作者只有在确定可变参数是类型安全的，才可以使用@SafeVarargs注解告知编译器不要警告，那怎样才是安全的，需要满足以下条件

• 不要使用可变参数存储任何值，很容易导致类型不匹配
• 不要暴露可变参数的引用

//使用可变参数存储了其它值，违反第一条
objects[0] = intList;

//暴露了可变参数引用，违反了第二条
static <T> T[] toArray(T... args) { 
    return args;
}

下面一个示例使用了上面的toArray方法，编译运行都是正常的，但要注意返回数组的类型是由传入的参数的编译时类型决定的，编译器可能没有足够的信息作准确的判断

public static void main(String[] args) {
                //传人的参数编译时类型为String
        String[] msg=toArray("one","two");
                //为Integer
        Integer[] integer=toArray(1,3,4);       
}
//下面是反编译的字节码  参数类型都变成了Object，但做了正确的类型转换
invokestatic  Method toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
checkcast     class "[Ljava/lang/String;"

invokestatic  Method toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
checkcast  class "[Ljava/lang/Integer;"

如果上面这个可以使用，下面这个应该也没什么问题

public static void main(String[] args) {        
    String[] reuslt=pickTwo("t1", "t2");
}

static <T> T[] pickTwo(T a, T b,) { 
  switch(ThreadLocalRandom.current().nextInt(3)) {
         case 0: return toArray(a, b);
         case 1: return toArray(a, c);
         case 2: return toArray(b, c);
    }
       throw new AssertionError(); // Can't get here
}
//没有checkcast，返回的就是Object数组，实际类型信息丢失
invokestatic    Method toArray:([Ljava/lang/Object;)[Ljava/lang/Object;

invokestatic    Method pickTwo(Ljava/lang/Object;Ljava/lang/Object;)[Ljava/lang/Object;
 checkcast               class "[Ljava/lang/String;"

实际上编译的时候确实没有问题，但运行起来就会报错：ava.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
因为此时toArray接受到的参数编译时类型为Object，所以返回的是Object数组，pickTwo接受到的也是Object数组，强转成String[]就报错。如果如下去除泛型，确定pickTwo的参数类型，也不会报错，只是没什么意义。

static String[] pickTwo(String t1,String t2){
        return  toArray(t1,t2); 
}

下面是一个典型的正确使用泛型可变参数的案例,注意：@SafeVarargs只能用在静态方法、不可覆盖方法和私有方法上(Java 9)

@SafeVarargs
static <T> List<T> flatten(List<? extends T>... lists) {
    List<T> result = new ArrayList<>();
       for (List<? extends T> list : lists)
          result.addAll(list); 
    return result;
}

如果你不想使用麻烦的泛型可变参数，可以使用集合替代，并配合Java 9中的List.of，它使用了@safeVarargs注解，是类型安全的

static <T> List<T> flatten(List<List<? extends T>> lists) {
    List<T> result = new ArrayList<>(); 
      for (List<? extends T> list : lists)
        result.addAll(list); 
    return result;
}

不过下面原书的例子我觉得是有问题的,编译不通过，参数类型不匹配

audience = flatten(List.of(friends, romans, countrymen));

前面有问题的代码就可以用集合解决，

public static void main(String[] args) {
    List<String> attributes = pickTwo("Good", "Fast", "Cheap");
}

static <T> List<T> pickTwo(T a, T b, T c) { 
    switch(rnd.nextInt(3)) {
      case 0: return List.of(a, b); 
      case 1: return List.of(a, c);
      case 2: return List.of(b, c);
  }
       throw new AssertionError();
 }

总的来说，可变参数底层使用的是数组，和泛型配合不好，如果可变参数要结合泛型，一定要遵守下面事项，保证安全才能用@safeVarargs注解

• 它没有在可变参数数组中保存任何值
• 它没有对不被信任的代码开发该数组

Item33 优选类型安全的异构容器

虽然按照规则使用泛型可以保证类型是安全的，但如果和原始类型混用泛型就有类型安全隐患，下面段代码编译的时候有unchecked warning，但可以运行，也就是整数1添加到了类型参数为String的集合中，只要不取出来涉及类型转换就不会发现问题

 List<String> a=new ArrayList<>();
//使用原始类型绕过泛型检查
 List b=a;
//成功添加
 b.add(1);

这是一种隐患，对于错误应该越早发现越好。Java SDK的Conllections工具类提供如下解决方法,除了泛型，还添加了String.class这个字面量,其传到方法作为参数表示的是Class<String>，它可以作为类型令牌

//checkedList返回一个对ArrayList的包装类
List<String> c=Collections.checkedList(new ArrayList<>(), String.class) ;
List d=c;
//添加失败
d.add(1);

//Collections.java
 public static <E> List<E> checkedList(List<E> list, Class<E> type) {
        return (list instanceof RandomAccess ?
                new CheckedRandomAccessList<>(list, type) :
                new CheckedList<>(list, type));
 }

上面这段代码编译的时候也有unchecked ，但运行就会报ClassCastException，原理就是添加之前利用Class<T>这个类型令牌作类型检查

Collections.CheckedCollection.java
public boolean add(E e) { 
    return c.add(typeCheck(e)); 
}


 E typeCheck(Object o) {
        //类型检查
    if (o != null && !type.isInstance(o))
       throw new ClassCastException(badElementMsg(o));
      return (E) o;
 }