java - 如何指定返回另一个具有类型协变的泛型类型的 java.util.Function？

Question

假设我想写一个方法，接受一个列表和一个 Function返回另一个通用类型，比如 Optional .这种方法的一个具体示例是将函数应用于列表中的所有元素，并返回未导致空 Optional 的所有元素的列表。 .

据我所知，下面是我将如何编写此方法:

public <I, O> List<O> transform(List<I> list, Function<? super I, Optional<? extends O>> function) {
  List<O> result = new ArrayList<>();
  for (I element : list) {
    Optional<? extends O> optional = function.apply(element);
    if (optional.isPresent()) {
      result.add(optional.get());
    }
  }
  return result;
}

我为 Function 使用通配符参数的原因如下:

• 我真的不在乎 Function 的输入正是I .传递父类型为 I 的任何内容应该没问题.
• Optional那Function返回不必完全是 O .返回 Optional 应该没问题O 的子类型.

让我们先定义两个简单的类型来测试一下:

public class Animal {}
public class Cat extends Animal {}

现在假设我们从 Cat 的列表开始小号:

List<Cat> catList = new ArrayList<>();

根据我做的两点关于transform采用上面的通配符参数，我想将此列表转换为另一个列表 Animal使用以下方法:

public Optional<Cat> animalToCat(Animal cat) {
  return Optional.empty();
}

当我将方法引用传递给 animalToCat 时，这确实有效:

List<Animal> animalList = transform(catList, this::animalToCat); // works!

但是，如果我没有直接使用此方法引用，并且想先将方法存储在变量中，然后再将其传递给 transform 怎么办？以后呢？

Function<Animal, Optional<Cat>> function2 = this::animalToCat;
List<Animal> animalList2 = transform(catList, function2); // does not compile!

为什么这行结果为 animalList编译，但结果为 animalList2不是吗？通过反复试验，我发现我确实可以通过更改我将我的方法引用分配给以下任何变量的变量类型来进行编译:

Function<Animal, Optional<? extends Animal>> function3 = this::animalToCat;
List<Animal> animalList3 = transform(catList, function3); // works

Function<Cat, Optional<? extends Animal>> function4 = this::animalToCat;
List<Animal> animalList4 = transform(catList, function4); // works

Function<? super Cat, Optional<? extends Animal>> function5 = this::animalToCat;
List<Animal> animalList5 = transform(catList, function5); // works

所以分配animalToCat似乎没问题方法引用，这显然是一个 Animal并返回 Optional<Cat> , 到其他 Function类型。但是，采用现有的 animalToCatFunction2并将其分配给其他类型也失败:

animalToCatFunction3 = animalToCatFunction2; // does not compile!
animalToCatFunction4 = animalToCatFunction2; // does not compile!
animalToCatFunction5 = animalToCatFunction2; // does not compile!

我很困惑为什么可以治疗 this::animalToCat以某种方式引用方法，使其看起来像返回的 Optional<Cat>是协变类型，但是一旦将引用分配给具有特定类型的变量，该行为就会突然中断。是我对 transform 的定义错了吗？

Answer 1

参见 STU's reply出于根本原因。

为了使您的示例正常工作，您需要通过使用更多类型参数来帮助 Java 类型系统:

<A, B, C extends B, D extends A> List<B> transform(List<D> list, Function<A, Optional<C>> function) {
    List<B> result = new ArrayList<>();
    for (D element : list) {
        Optional<C> optional = function.apply(element);
        if (optional.isPresent()) {
            result.add(optional.get());
        }
    }
    return result;
}

由于传入列表的动态子类型可能与传出列表不同，因此向示例添加另一个子类型很有用:

class Dog extends Animal {}

那么示例代码是:

List<Dog> dogList = new ArrayList<>();
List<Animal> animalList = transform(dogList, this::animalToCat);

Function<Animal, Optional<Cat>> function2 = this::animalToCat;
List<Animal> animalList2 = transform(dogList, function2);

编辑:稍微修改了类型约束，使其也适用于评论中的示例:

Optional<Animal> catToAnimal(Cat cat) {
    return Optional.empty();
}

Function<Cat, Optional<Animal>> function2b = this::catToAnimal;
List<Animal> animalList2b = transform(catList, function2b);