看《Effective Java》学会的泛型设计

一 先来小菜一碟

看代码：

    public static <E> void christmas(List<E> list) {        E[] snapshot = list.toArray();        for (E e : snapshot) {            //         }    }

上面这段代码是编译不通过的， 出现了error:

Error:(56, 36) java: 不兼容的类型: java.lang.Object[]无法转换为E[]

也可以：

E[] snapshot = (E[])list.toArray();

加上这样的强制转换，compiler 在compile时会提示warning: unchecked cast: 'java.lang.Object[]' to 'E[]'
表明这里是类型不安全的，这样的转换是不好的。

根据《Effective Java》中所叙述的，数组和泛型有着非常不同的类型规则，数组是协变(covariant)和具体化的(reified)，泛型是不可变(invariant)且可以被擦除的(erased)。数组提供了运行时类型的安全，但是没有编译时的类型安全。数组和泛型不能很好的混合使用，如果发现将它们混合起来使用，并且得到了编译时错误或警告，就应该是用List去代替Array。
上面的代码就可以修改为:

    public static <E> void christmas(List<E> list) {        List<E> snapshot = new ArrayList<>(list);        for (E e : snapshot) {            //         }    }

二 上主菜

内容都是来自《Effective Java》,记录以备后续学习。
下面的代码模拟 数据结构 栈(Stack)。

Stack 版本一

import java.util.Arrays;import java.util.EmptyStackException;public class StackDemo {    private Object[] elements;    private int size = 0;    private static final int DEFAULT_INITIAL_CAPACITY = 16;    public StackDemo() {        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; // Eliminate obsolete reference        return result;    }    public boolean isEmpty() {        return size == 0;    }    private void ensureCapacity() {        if (elements.length == size)            elements = Arrays.copyOf(elements, 2 * size + 1);    }}

为了让Stack泛型化并支持更多的类型，将StackDemo类中的Object替换成 形式类型参数 E，如下：

Stack版本二

import java.util.Arrays;import java.util.EmptyStackException;public class StackGericDemo<E> {    private E[] elements;    private int size = 0;    private static final int DEFAULT_INITIAL_CAPACITY = 16;    public StackGericDemo() {        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; // Eliminate obsolete reference        return result;    }    public boolean isEmpty() {        return size == 0;    }    private void ensureCapacity() {        if (elements.length == size)            elements = Arrays.copyOf(elements, 2 * size + 1);    }}

然而
elements = new E[DEFAULT_INITIAL_CAPACITY];
这行代码是有问题的，不能这样去创建数组，compiler报error错误。compiler表示不能证明你的程序是类型安全的。
为了抑制掉error错误, 可以加上泛型转换

elements = (E[]) new Object[DEFAULT_INITIAL_CAPACITY];

这样compiler就只会报unchecked cast的warning了，谢天谢地，但问题还没解决。

由于E是一个不可具体化的(non-reifiable), 编译器不能确定你的程序是类型安全的，但是写代码的你可以证明啊。elements这个变量保存在一个private字段中，没有提供对应的client可以访问到elements的方法，保存到elements中的值是通过push方法加进去的，是E类型的，so compiler爆出的unchecked cast warning对这个Stack的程序是没有危害的(no harm)。

一旦你证实到这样的unchecked cast是安全的，在小局部范围使用@SuppressWarnings("unchecked")
将这个警告给抑制掉吧（作为一个有代码洁癖的你）。

新版本的Stack Java Code:

import java.util.Arrays;import java.util.EmptyStackException;public class StackGericDemo<E> {    private E[] elements;    private int size = 0;    private static final int DEFAULT_INITIAL_CAPACITY = 16;    // The elements array will contain only E instances from push(E).    // This is sufficient to ensure type safety, but the runtime    // type of the array won't be E[]; it will always be Object[]!    @SuppressWarnings("unchecked")    public StackGericDemo() {        /**         *  you can’t create an array of a non-reifiable type, such as E         *  不能创建不可具体化的数组         *///        elements = new E[DEFAULT_INITIAL_CAPACITY];        /**         * 这是类型不安全的         * 但这里是能保证这个程序是类型安全的，因为指定了类型参数 E         * 这里的 unchecked cast can do no harm         */        elements = (E[]) new Object[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; // Eliminate obsolete reference        return result;    }    public boolean isEmpty() {        return size == 0;    }    private void ensureCapacity() {        if (elements.length == size)            elements = Arrays.copyOf(elements, 2 * size + 1);    }}

Stack版本三

还有一种方法是将E[]换成Object[] , code :

import java.util.Arrays;import java.util.EmptyStackException;public class StackGericPerfectDemo<E> {    private Object[] elements;    private int size = 0;    private static final int DEFAULT_INITIAL_CAPACITY = 16;    public StackGericPerfectDemo() {        elements = new Object[DEFAULT_INITIAL_CAPACITY];    }    public void push(E e) {        ensureCapacity();        elements[size++] = e;    }    public E pop() {        if (size == 0)            throw new EmptyStackException();        /**         * unchecked cast, 是否能转换         *         Stack.java:19: warning: [unchecked] unchecked cast         found   : Object, required: E         E result = (E) elements[--size];         Because E is a non-reifiable type,         there’s no way the compiler can check the cast at runtime.         */        // push requires elements to be of type E, so cast is correct        @SuppressWarnings("unchecked")        E result = (E) elements[--size];        elements[size] = null; // Eliminate obsolete reference        return result;    }    public boolean isEmpty() {        return size == 0;    }    private void ensureCapacity() {        if (elements.length == size)            elements = Arrays.copyOf(elements, 2 * size + 1);    }}

版本二和版本三相比，禁止an uncheck cast to an array type 比禁止a scalar type(标量类型)要更加危险一些，所以建议还是版本三的方案。但是Stack的实际的使用中，会在代码的多个地方从数组中读取值，选择版本三的方案的话会需要many cast to E，版本二只需要a single cast to E[]，由此版本二的Stack的泛型设计会更常用一点。