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