Java 泛型（三）

泛型的通配符

 

1 、为什么需要类型通配符..

遍历集合

• 没有泛型

public void test(List list){


    for(int i=0;i<list.size();i++){
        
        System.out.println(list.get(i));
    
    }
}

上面的代码是正确的，只不过在编译的时候会出现警告，说没有确定集合元素的类型....

• 用泛型：

public void test(List<Object> list){


    for(int i=0;i<list.size();i++){
        
        System.out.println(list.get(i));
    
    }
}

该test()方法只能遍历装载着Object的集合。

泛型中的<Object>并不是像以前那样有继承关系的，也就是说List<Object>和List<String>是毫无关系的。

不清楚List集合装载的元素是什么类型的，List<Objcet>这样是行不通的........

于是Java泛型提供了类型通配符 “?”

 代码应该改成：

public void test(List<?> list){


    for(int i=0;i<list.size();i++){
        
        System.out.println(list.get(i));
    
    }
}

?号通配符表示可以匹配任意类型，任意的Java类都可以匹配.....

 注意：

使用?号通配符的时候：就只能调对象与类型无关的方法，不能调用对象与类型有关的方法。

因为直到外界使用才知道具体的类型是什么。

也就是说，在上面的List集合，是不能使用add()方法的。

因为add()方法是把对象丢进集合中，而现在是不知道对象的类型是什么。

 

 

2 、泛型中有三种通配符形式：

<?> 无限制通配符
<? extends E> extends 关键字声明了类型的上界，表示参数化的类型可能是所指定的类型，或者是此类型的子类
<? super E> super 关键字声明了类型的下界，表示参数化的类型可能是指定的类型，或者是此类型的父类

 

2.1、无限制通配符 < ?>

表示可以持有任何类型。
在不确定或者不关心实际要操作的类型的情况下使用。

大部分情况下，这种限制是好的，但这使得一些理应正确的基本操作都无法完成，比如交换两个元素的位置，看代码：

private void swap(List<?> list, int i, int j){
    Object o = list.get(i);
    list.set(j,o);
}

这个代码看上去应该是正确的，但 Java 编译器会提示编译错误，set 语句是非法的。编译器提示我们把方法中的 List<?> 改成 List<Object> 就好了，因为 ? 和 Object 不一样，List<?> 表示未知类型的列表，而 List<Object> 表示任意类型的列表。

比如传入个 List<String> ，这时 List 的元素类型就是 String，想要往 List 里添加一个 Object，这当然是不可以的。

借助带类型参数的泛型方法，这个问题可以这样解决：

 private <E> void swapInternal(List<E> list, int i, int j) {
    //...
    list.set(i, list.set(j, list.get(i)));
}

private void swap(List<?> list, int i, int j){
    swapInternal(list, i, j);
}

swap 可以调用 swapInternal，而带类型参数的 swapInternal 可以写入。Java容器类中就有类似这样的用法，公共的 API 是通配符形式，形式更简单，但内部调用带类型参数的方法。

 

2.2、上界通配符 < ? extends E>

一个List集合，它只能操作数字类型的元素【Float、Integer、Double、Byte等数字类型都行】

直接使用通配符的话，该集合就不是只能操作数字了。因此我们需要用到设定通配符上限

List<? extends Number>

表示的是：List集合装载的元素只能是Number的子类或自身

    public static void main(String[] args) {


        //List集合装载的是Integer，可以调用该方法
        List<Integer> integer = new ArrayList<>();
        test(integer);

        //List集合装载的是String，在编译时期就报错了
        List<String> strings = new ArrayList<>();
        test(strings);

    }


    public static void test(List<? extends Number> list) {
        
    }

 

在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类，这样有两个好处：

• 如果传入的类型不是 E 或者 E 的子类，编辑不成功
• 泛型中可以使用 E 的方法，要不然还得强转成 E 才能使用

 

2.3、下界通配符 < ? super E>

 

泛型中的参数必须是 E 或者 E 的父类。

 //传递进来的只能是Type或Type的父类
    <? super Type>

 public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }

创建一个TreeSet<String>类型的变量的时候，并传入一个可以比较String大小的Comparator。

那么这个Comparator的选择就有很多了，它可以是Comparator<String>，还可以是类型参数是String的父类，比如说Comparator<Objcet>....

 

3、通配符比较

无限制通配符 < ?> 和 Object 有些相似，用于表示无限制或者不确定范围的场景。

两种有限制通配形式 < ? super E> 和 < ? extends E> 也比较容易混淆。

它们的目的都是为了使方法接口更为灵活，可以接受更为广泛的类型。

< ? super E> 用于灵活写入或比较，使得对象可以写入父类型的容器，使得父类型的比较方法可以应用于子类对象。
< ? extends E> 用于灵活读取，使得方法可以读取 E 或 E 的任意子类型的容器对象。

用《Effective Java》 中的一个短语来加深理解：

为了获得最大限度的灵活性，要在表示 生产者或者消费者 的输入参数上使用通配符，使用的规则就是：生产者有上限、消费者有下限：

PECS: producer-extends, costumer-super

因此使用通配符的基本原则：

• 如果参数化类型表示一个 T 的生产者，使用 < ? extends T>;
• 如果它表示一个 T 的消费者，就使用 < ? super T>；
• 如果既是生产又是消费，那使用通配符就没什么意义了，因为你需要的是精确的参数类型。

小总结一下：

• T 的生产者的意思就是结果会返回 T，这就要求返回一个具体的类型，必须有上限才够具体；
• T 的消费者的意思是要操作 T，这就要求操作的容器要够大，所以容器需要是 T 的父类，即 super T；

举个例子：

    private  <E extends Comparable<? super E>> E max(List<? extends E> e1){
        if (e1 == null){
            return null;
        }
        //迭代器返回的元素属于 E 的某个子类型
        Iterator<? extends E> iterator = e1.iterator();
        E result = iterator.next();
        while (iterator.hasNext()){
            E next = iterator.next();
            if (next.compareTo(result) > 0){
                result = next;
            }
        }
        return result;
    }

上述代码中的类型参数 E 的范围是 <E extends Comparable<? super E>>，我们可以分步查看：

要进行比较，所以 E 需要是可比较的类，因此需要 extends Comparable<…>（注意这里不要和继承的 extends 搞混了，不一样）
Comparable< ? super E> 要对 E 进行比较，即 E 的消费者，所以需要用 super
而参数 List< ? extends E> 表示要操作的数据是 E 的子类的列表，指定上限，这样容器才够大
 

 

在泛型的上限和下限中原则：PECS(Producer Extends Consumer Super)

书上是这样写的：

带有子类限定的可以从泛型读取【也就是--->(? extend T)】-------->Producer Extends
带有超类限定的可以从泛型写入【也就是--->(? super T)】-------->Consumer Super