Java 8谓词 - 为什么不能加入通配符泛型谓词？

Question

请考虑以下代码：

public class Main {
    private static Predicate<? extends TestObject> predicate = testObject -> true;
    private static Predicate<? extends TestObject> predicate1 = testObject -> true;

    public static void main( String[] args ) {

         List<TestObject> objects = Lists.newArrayList( new TestObject(), new TestObject() );

         objects.stream().filter( predicate.or( predicate1 ) ).findFirst();
    }
}

它没有编译，给出错误：

Error:(17, 48) java: incompatible types: java.util.function.Predicate<capture#1 of ? extends test.test.TestObject> cannot be converted to java.util.function.Predicate<? super capture#2 of ? extends test.test.TestObject>

看起来我们不能用“或”或“和”这样的逻辑运算符加入这样的谓词，但为什么Java不能处理它们呢？

它使用像Predicate<TestObject>这样的简单谓词进行编译，但不能用Predicate<? super TestObject> Predicate<? super TestObject>或Predicate<? extends TestObject> Predicate<? extends TestObject> 。

Answer 1

您可能知道谓词是兼容的，但编译器不兼容。

想象一下这个例子：

Predicate<? extends Collection<Object>> p1 = (Set<Object> s) -> s.isEmpty();
Predicate<? extends Collection<Object>> p2 = (List<Object> l) -> l.get(0) != null;

我们的开发人员可以看到第一个谓词可以在技术上处理所有集合，而第二个谓词只能处理列表。 但是想象一下，谓词在其他地方被初始化，或者在此期间会被改变。 编译器无法确定谓词对象的集合类型。 因此，您根本无法使用它们：

Set<Object> set = new HashSet<>();
List<Object> list = new ArrayList<>();
p1.test(set);
p2.test(list);
p1.test(list);
p2.test(set);

所有这些调用都不会编译，因为编译器无法确定p1和p2后面的实际对象是否完全适用于那些类型的集合。 那是? extends Collection<>意思? extends Collection<> ? extends Collection<> ：你知道它是一个特定的子类型，但你无法告诉编译器究竟是哪一个。

---

用一个更简单的例子来说明这一点：

Collection<Apple> appleBasket = ...;
appleBasket.add(new Apple());  // works
appleBasket.add(new Orange()); // does not work (obviously)

Collection<Fruit> mixedFruitBasket = ...;
mixedFruitBasket.add(new Apple());  // works
mixedFruitBasket.add(new Orange()); // works

// Now the tricky part
Collection<? extends Fruit> unknownButPureFruitBasket = ...;
unknownButPureFruitBasket.add(new Apple());  // does not work 
unknownButPureFruitBasket.add(new Orange()); // does not work

您不能将任何一种水果添加到您不知道的类型的篮子中。 它实际上可以是一个接受所有水果的篮子，但它可能是一个纯苹果篮子，橙色支持，甚至是你甚至还不知道的香蕉篮子。

在IDE中尝试：

List<? extends String> l1 = new ArrayList<>();
List<? extends String> l2 = new ArrayList<>();
l1.addAll(l2);

Eclipse告诉我：

方法addAll（Collection1-of？extends String>）在List <capture＃ 1 -of？中。 extends String>不适用于参数（List <capture＃ 2 -of？extends String>）

注意不同的类型： addAll需要capture#1的集合， l2是capture#2的集合。

Answer 2

filter需要Predicate<? super TestObject> Predicate<? super TestObject> ，而不是Predicate<? extends TestObject> Predicate<? extends TestObject> 。

为什么super TestObject ？ 因为这里的TestObject是一个输入参数，一个消费者 。 根据PECS规则，它应该标记为超级。

Predicate<? extends TestObject> Predicate<? extends TestObject>与Predicate<? super TestObject>完全不同Predicate<? super TestObject> Predicate<? super TestObject> 。 前者可以接受TestObject和TestObject所有子类。 后者可以接受TestObject和TestObject所有超类。 显然它们是不同的，不兼容的。

Answer 3

这实际上不是关于Java如何处理谓词，而只是一个泛型问题。

简而言之，答案是predicate和predicate1不一定兼容。 所述类型的参数的来or是Predicate<? super T> Predicate<? super T> ，假设两个Predicate对象中的T是相同的具体类型参数。 但这种情况并非如此。

为了说明问题，假设：

class TestObject2 extends TestObject {
    boolean isTrue() {
        return true;
    }
}
class TestObject3 extends TestObject {
    boolean isTrue3() {
        return true;
    }
}

并且（注意声明的类型没有改变，但实际的lambda表达式确实如此）：

private static Predicate<? extends TestObject> predicate = 
        (TestObject2 testObject) -> testObject.isTrue();
private static Predicate<? extends TestObject> predicate1 = 
        (TestObject3 testObject) -> testObject.isTrue3();

在此示例中， or将获取错误的值（ predicate接受TestObject2对象，但在这种情况下，可以使用TestObject3对象调用它）。

您如何看待predicate1在此filter ？

Stream.of(new TestObject2(), new TestObject2()).filter(predicate.or(predicate1));

事实是，编译器保证Predicate<? extends TestObject> Predicate<? extends TestObject>兼容Predicate<TestObject2>和Predicate<TestObject3> （根据泛型法则）

Answer 4

这又是PECS，因为你通过Predicate 消耗了一些TestObject ，你需要? super TestObject ? super TestObject