Java笔记：泛型、限定通配符与非限定通配符

1 泛型

在集合中存储对象并在使用前进行类型转换是多么的不方便。泛型防止了那种情况的发生。 它提供了编译期的类型安全，确保你只能把正确类型的对象放入集合中，避免了在运行时出现ClassCastException。

• 不使用泛型

/**
 * 这样做的一个不好的是Box里面现在只能装入String类型的元素，今后如果我们需要装入Integer等其他类型的元素，
 * 还必须要另外重写一个Box，代码得不到复用，使用泛型可以很好的解决这个问题。
 */
public class Box {
    private String object;

    public void set(String object) {
        this.object = object;
    }

    public String get(){
        return object;
    }
}

• 使用泛型

public class  GenericBox<T> {
    // T stands for "Type"
    private T t;
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

2 限定通配符与非限定通配符

2.1 限定通配符

限定通配符对类型进行了限制。有两种限定通配符：

1. <? extends T>它通过确保类型必须是T及T的子类来设定类型的上界；
2. <? super T>它通过确保类型必须是T及T的父类设定类型的下界；

泛型类型必须用限定的类型来进行初始化，否则会导致编译错误。

2.2 非限定通配符

表示了非限定通配符，因为可以用任意类型来替代。

public class BoundaryCharExample {
    //查找一个泛型数组中大于某个特定元素的个数
    public static <T> int countGreaterThan(T[] array,T elem){
        int count = 0;
        for (T e : array) {
            if (e > elem) { // compiler error
                ++count;
            }
        }
        return count;
    }
    /*
    * comliler error:但是这样很明显是错误的，
    * 因为除了short, int, double, long, float, byte, char等原始类型，
    * 其他的类并不一定能使用操作符" > "
    * 解决 --> 使用限定通配符/边界符
    * */
}

使用限定通配符改进：

public class BoundaryCharExample2 {
    public static <T extends Comparable<T>> int countGreaterThan(T[] array,T elem){
        //<T extends Comparable<T>>就是通配符，类型必须是 Comparable<T>及其子类
        int count = 0;
        for (T e : array) {
            if (e.compareTo(elem)>0) {
                ++count;
            }
        }
        return count;
    }
}

3 PECS(Producer Extends Consumer Super)原则

• Producer Extends：如果你需要一个只读List，用它来produce T，那么使用? extends T；
• Consumer Super：如果你需要一个只写List，用它来consume T，那么使用? super T；

3.1 Producer Extends

对于实现了<? extends T>的集合类只能将它视为 Producer 向外提供(get)元素, 而不能作为 Consumer 向外获取(add)元素。

public class GenericExample {
    public static void main(String[] args) {
        List<? extends Fruit> fruits = new ArrayList<Apple>();
        //? extends Fruit表示的是Fruit及其子类
        
        // Compile Error: can't add any type of object:
        //fruits.add(new Apple());
        //fruits.add(new Orange());
        //fruits.add(new Fruit());
        //fruits.add(new Object());
        //fruits.add(null); // Legal but uninteresting
    }
}

Compile Error: can’t add any type of object：

从编译器的角度去考虑，List<? extends Fruit> fruits自身可以有多种含义：

List<? extends Fruit> fruits = new ArrayList<Fruit>();

List<? extends Fruit> fruits = new ArrayList<Apple>();

List<? extends Fruit> fruits = new ArrayList<Orange>();

// 这里Apple和Orange都是Fruit子类

1. 当我们尝试add一个Apple的时候，fruits可能指向new ArrayList< Orange >();
2. 当我们尝试add一个Orange的时候，fruits可能指向new ArrayList< Apple >();
3. 当我们尝试add一个Fruit的时候，这个Fruit可以是任何类型的Fruit，而fruits可能只想是某种特定类型的Fruit，因此编译器无法识别，报错。

应用示例：

public class GenericReading {
    private List<Apple> apples = Arrays.asList(new Apple());
    private List<Fruit> fruit = Arrays.asList(new Fruit());

    private class Reader<T>{ //Reader<T> 是自定义的泛型类
         /*T readExact(List<T> list){ 
             return list.get(0);
         }*/
        T readExact(List<? extends T> list){// 使用通配符来解决这个问题
            // ? extends T 表示 T 及 T 的子类
            return list.get(0); //TODO :get()方法
        }
    }

    @Test
    public void test(){
        Reader<Fruit> fruitReader=new Reader<Fruit>();
        //Fruit f=fruitReader.readExact(apples);
        // 使用 readExact(List<T> list)  
        // Errors: List<Fruit> cannot be applied to List<Apple>.
        
        Fruit f=fruitReader.readExact(apples);//正确
        System.out.println(f);
    }
}

3.2 Consumer Super

对于实现了<? super T>的集合类只能将它视为 Consumer 向外获取(add)元素, 而不能作为 Producer 向外提供(get)元素。

从编译器的角度考虑，对于List<? super Apple> list，它可以有下面几种含义：

List<? super Apple> list = new ArrayList<Apple>();
List<? super Apple> list = new ArrayList<Fruit>();
List<? super Apple> list = new ArrayList<Object>();

当我们尝试通过list来get一个Apple的时候，可能会get得到一个Fruit，这个Fruit可以是Orange等其他类型的Fruit，因此编译器无法识别，报错。

应用示例：

public class GenericWriting {
    private List<Apple> apples = new ArrayList<Apple>();
    private List<Orange> oranges = new ArrayList<Orange>();
    private List<Fruit> fruit = new ArrayList<Fruit>();

    <T> void writeExact(List<T> list, T item) {
        list.add(item); //TODO :这里是 add
    }

    // ? super T 
    // T 及 T 的父类
    <T> void writeWithWildcard(List<? super T> list, T item) {
        list.add(item);
    }

    void func1(){
        writeExact(apples,new Apple());
        writeExact(fruit,new Apple());
    }

    void func2(){
        writeWithWildcard(apples, new Apple());
        writeWithWildcard(fruit, new Apple());
    }

    @Test
    public void test(){
        func1();
        func2();
    }
}

JDK 8 Collections.copy() 源码:

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        //dest 就是 只写的 List
        //src 就是 只读的 List
        int srcSize = src.size();
        if (srcSize > dest.size())
            throw new IndexOutOfBoundsException("Source does not fit in dest");

        if (srcSize < COPY_THRESHOLD ||
            (src instanceof RandomAccess && dest instanceof RandomAccess)) {
            for (int i=0; i<srcSize; i++)
                dest.set(i, src.get(i));
        } else {
            ListIterator<? super T> di=dest.listIterator();
            ListIterator<? extends T> si=src.listIterator();
            for (int i=0; i<srcSize; i++) {
                di.next();
                di.set(si.next());
            }
        }
    }

RandomAccess是一个空的、用来标记的接口；

用处是当要实现某些算法时，会判断当前类是否实现了RandomAccess接口，会选择不同的算法；

接口RandomAccess中内容是空的，只是作为标记用。比如List下的ArrayList和LinkedList。其中ArrayList实现了RandomAccess。而LinkedList没有。我们可以利用instanceof来判断哪一个是实现了RandomAccess。分辨出两个集合。其中ArrayList使用for循环遍历快，而LinkedList使用迭代器快。那么通过分辨，不同的集合使用不同的遍历方式；