【05】Effective Java - 泛型

一、不要在新代码中使用原生态类型

List<String>的原生态类型就是List，即擦除了泛型信息。

使用泛型，能够不在编译时期发现类型不匹配错误。

List<String>是List的的一个子类型，但不是List<Object>的子类型。

（1）无限制通配符

即便用泛型，但不肯定或者不关心实际的类型参数

例如Set<E>的无限制通配符类型为Set<?>，即由E类型的Set变为某个类型的Set。它与Set的区别在于通配符类型是安全的，原生态类型是不安全的。你能够将任何类型放入到原生态Collection中，可是没法将任何元素（除null以外）放到Collection<?>中，由于编译器没法识别是哪一种类型的对象。

二、消除非受检警告

若是没法消除警告，同时能够证实引发警告的代码是类型安全的，能够用@SuppressWarnings("unchecked")注解来禁止这条警告。

若是本身没有证实是类型安全的，仍然加这个注解，编译时没有警告，可是运行时若是类型不对，抛出ClassCastException

三、列表优于数组

（1）数组是协变的，泛型则是不可变的

Object[] objArr = new Long[1];
objArr[0] = "hello"; //throw ArraysStoreException

 上面代码是合法的，可是运行时会抛异常；而下面这段代码则编译不经过。

List<Object> o1 = new ArrayList<Long>();
o1.add("hello");

（2）数组是具体化的，泛型是类型擦除的

数组是具体化的，于是在运行时才知道并检查其元素的类型约束。

泛型是类型擦除的，只能在编译时强化它们的类型信息，并在运行时擦除它们的元素类型信息，于是只能在编译阶段检查。

于是数组和泛型不能很好混合使用，好比List<E>[]，new List<String>[]，new E[]都是非法的。

总结：数组提供了运行时的类型安全，泛型则提供了编译时的类型安全。

四、优先考虑泛型

public class Stack<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 Stack() {
        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);
    }

    // Little program to exercise our generic Stack
    public static void main(String[] args) {
        Stack<String> stack = new Stack<String>();
        for (String arg : args)
            stack.push(arg);
        while (!stack.isEmpty())
            System.out.println(stack.pop().toUpperCase());
    }
}

  方案二

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

    // Appropriate suppression of unchecked warning
    public E pop() {
        if (size==0)
            throw new EmptyStackException();

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

    // Little program to exercise our generic Stack
    public static void main(String[] args) {
        Stack<String> stack = new Stack<String>();
        for (String arg : args)
            stack.push(arg);
        while (!stack.isEmpty())
            System.out.println(stack.pop().toUpperCase());
    }
}

五、优先考虑泛型方法

（1）泛型静态工厂

public static <K,V> HashMap<K,V> newHashMap(){
   return new HashMap<K,V>();
}

（2）泛型单例工厂

public interface UnaryFunction<T>{
   T apply(T arg);
}

六、利用有限制的通配符提高API的灵活性

// Wildcard type for parameter that serves as an E producer
    public void pushAll(Iterable<? extends E> src) {
        for (E e : src)
            push(e);
    }

显示类型参数

Set<Number> numbers = Union.<Number>union(integers, doubles);

七、优先考虑类型安全的异构容器

public class Favorites {
    // Typesafe heterogeneous container pattern - implementation
    private Map<Class<?>, Object> favorites = 
        new HashMap<Class<?>, Object>();

    public <T> void putFavorite(Class<T> type, T instance) {
        if (type == null)
            throw new NullPointerException("Type is null");
        favorites.put(type, instance);
    }

    public <T> T getFavorite(Class<T> type) {
        return type.cast(favorites.get(type));
    }


    // Typesafe heterogeneous container pattern - client
    public static void main(String[] args) {
        Favorites f = new Favorites();
        f.putFavorite(String.class, "Java");
        f.putFavorite(Integer.class, 0xcafebabe);
        f.putFavorite(Class.class, Favorites.class);

        String favoriteString = f.getFavorite(String.class);
        int favoriteInteger = f.getFavorite(Integer.class);
        Class<?> favoriteClass = f.getFavorite(Class.class);
        System.out.printf("%s %x %s%n", favoriteString,
                          favoriteInteger, favoriteClass.getName());
    }
}

  利用Class的cast方法，将对象引用动态地转换为Class对象所表示的类型。这种方法的局限在于不能用于不可具体化的类型当中，好比List<String>，由于List<String>.class是语法错误。

   能够用DatabaseRaw类型表示一个数据库行，用泛型Column<T>做为它的键。