与通用供应商和lambda进行类型检查

Question

private <T> void compareValues(Supplier<T> supplier, T value) {
    System.out.println(supplier.get() == value);
}

private <T> void setValue(Consumer<T> consumer, T value) {
    consumer.accept(value);
}

compareValues(this::getString, "Foo"); // Valid, as expected
compareValues(this::getInt, "Foo");    // Valid, but compiler should raise error
compareValues(this::getString, 1);     // Valid, but compiler should raise error

setValue(this::setString, "Foo");      // Valid, as expected
setValue(this::setInt, "Foo");         // Type mismatch, as expected
setValue(this::setString, 1);          // Type mismatch, as expected


private String getString() {
    return  "Foo";
}

private int getInt() {
    return 1;
}

private void setString(String string) {
}

private void setInt(int integer) {
}

怎么会呢？编译器只是太笨拙，无法在这里正确地推理类型，还是这是类型系统的一个特性？如果有，导致这种行为的规则是什么？此外，如果可能的话，我如何创建compareValues的“类型安全”版本而不添加人工参数？

请注意，所提供的方法仅仅包含一个虚拟实现，并不反映我的实际代码库中的代码。这里的重点仅仅是方法调用。

Answer 1

其他人已经提到了为什么会发生这种情况，所以这里有一个解决方案来绕过这个问题。

如果您创建一个泛型类，将供应商的传递与参数的传递分开，那么您就没有给编译器选择交集类型的机会：

public class Comparer<T>
{
    private final Supplier<T> supplier;

    Comparer(final Supplier<T> supplier)
    {
        this.supplier = supplier;
    }

    void compare(T value)
    {
        System.out.println(supplier.get() == value);
    }
}

new Comparer<>(this::getString).compare("Foo"); // Valid, as expected
new Comparer<>(this::getInt).compare("Foo"); // Invalid, compiler error
new Comparer<>(this::getString).compare(1);  // Invalid, compiler error

通过分离这种行为，您还允许comparer做一些可能有用的事情，比如缓存supplier.get()的结果。