Java 'reduceLeft' 签名/下界类型参数

Question

以下签名在 Scala 中有效且常用：

trait Collection[A] {
    def reduceLeft [B >: A] (f: (B, A) => B): B
}

但是，由于>: 是 Java 中 super 的 Scala 等价物，我转换此签名的第一个想法（将函数类型替换为 BiFunction 并使用 Use-Site 差异注释，即有界通配符）将是

interface Collection<A> {
    <B super A> B reduceLeft(BiFunction<? super B, ? super A, ? extends B> mapper)
}

但是哦不！编译器抱怨<B super A> 中的super 标记，因为你不能有下界类型变量！现在，我如何在 Java 代码中编写这个方法，而不必穿越到 Java 世界中不存在泛型的时候？

---

是的，我知道你认为我可以使用B extends A，但那不是一回事，正如我的实现所示：

public <R extends E> R reduceLeft(BiFunction<? super R, ? super E, ? extends R> mapper)
{
    if (this.isEmpty())
    {
        return null;
    }

    Iterator<E> iterator = this.iterator();
    R first = iterator.next(); // doesn't work, but would if R was a super-type of E (R super E)
    while (iterator.hasNext())
    {
        mapper.apply(first, iterator.next());
    }

    return first;
}

相反，我不得不使用这个稍微受限的版本：

public E reduceLeft(BiFunction<? super E, ? super E, ? extends E> mapper)
{
    if (this.isEmpty())
    {
        return null;
    }

    Iterator<E> iterator = this.iterator();
    E first = iterator.next();
    while (iterator.hasNext())
    {
        first = mapper.apply(first, iterator.next());
    }

    return first;
}

Answer 1

Scala 方法定义中的B >: A 约束是必要的，因为：

1. Scala 使用声明站点变化，并且不可变集合在它们包含的元素类型上是协变。
2. 从概念上讲，reduceLeft 需要返回 A 类型的值，但是使用 A 作为返回类型意味着在协变位置使用它，这与已经声明的方差冲突，即 A 必须是协变的。

解决这种差异冲突的技巧是引入 B 泛型类型。

现在，正如您所提到的，Java 采用了使用点变化，因此任何用 Java 编写的集合都是不变的。这也意味着使用A 作为方法的返回类型没有问题，即在逆变位置。所以，下面的定义就足够了——不需要B 类型：

interface Collection<A> {
  A reduceLeft(BiFunction<? super A, ? super A, ? extends A> reducer);
}

但是，如您所见，将A 设置为下限然后设置上限的净效果是A 基本上是不变的——如果不使用向下转换，就不可能从通配符边界中受益。这意味着我们可以简化签名（与Stream.reduce 非常相似）：

interface Collection<A> {
  A reduceLeft(BiFunction<A, A, A> reducer);
}

此外，BiFunction<A, A, A> 类型已经存在于 Java 8 中，名称为 BinaryOperator<A>。

Answer 2

你不能； Java 认为这个功能还不够有用。由于 Java 更多地使用高阶函数，这可能会改变。

我将通过接受一个“见证”A <: B 的函数来模拟此功能：

interface Collection<A> {
  static class Witness {
    static <B, A extends B> Function<A, B> witness() {
    return new Function<A, B> {
      public B apply(A value) {
        return value;
      }
    };
  }
  //Could take a custom type instead of Function if we want to enforce
  //that arbitrary functions aren't passed.
  //Could also just use foldLeft rather than reduceLeft
  <B> B reduceLeft(BinaryOperator<B, B, B> mapper, Function<A, B> witness);
}

Collection<Double> collectionOfDoubles = ...
BinaryOperator<Number, Number, Number> numberFunction = ...
//I haven't tested whether we need to pass explicit type arguments
collectionOfDoubles.reduceLeft(numberFunction, Collection.Witness.witness());

但是我们在这里开始了 greensupunning 的道路。

请注意，方差中存在实际值；与例如@Ionut 的解决方案，collectionOfDoubles.reduceLeft 调用是不可能的，因为Double 和Number 不是同一类型。

Answer 3

一个简单的解决方案是使用static 方法。然后您可以同时声明Collection 的元素类型和归约的返回类型，从而轻松声明E extends R 与它的关系：

public static <R, E extends R> R reduceLeft(
    Collection<? extends E> c, BiFunction<? super R, ? super E, ? extends R> mapper) {
    if(c.isEmpty()) return null;
    Iterator<? extends E> iterator = c.iterator();
    R value = iterator.next();
    while(iterator.hasNext()) value=mapper.apply(value, iterator.next());
    return value;
}

这种方法的一个直接优势是它适用于所有集合，而不仅仅是你声明方法的类型。

请注意，如果您为函数请求适当的标识值，您也可以完全删除元素类型和结果类型之间的关系，Stream API 也支持这一点。这也修复了您为空集合返回 null 的实现的缺陷：

public static <R, E> R reduceLeft(Collection<? extends E> c,
                      R identity, BiFunction<? super R, ? super E, ? extends R> mapper) {
    if(c.isEmpty()) return identity;
    R value=identity;
    for(E e: c) value=mapper.apply(value, e);
    return value;
}

现在它不需要声明E 和R 之间的关系，这个版本也可以是您的集合类型的实例方法：

public <R> R reduceLeft(R identity, BiFunction<? super R, ? super E, ? extends R> mapper) {
    if(isEmpty()) return identity;
    R value=identity;
    for(E e: this) value=mapper.apply(value, e);
    return value;
}

但是如果你不喜欢提供标识值的要求，你也可以提供一个函数用于第一个元素的初始转换，这对于R 是@ 的超类型的情况来说是微不足道的987654332@:

public <R> R reduceLeft(Function<? super E, ? extends R> cast,
                        BiFunction<? super R, ? super E, ? extends R> mapper) {
    if(isEmpty()) return null;
    Iterator<E> it=iterator();
    R value=cast.apply(it.next());
    while(it.hasNext()) value=mapper.apply(value, it.next());
    return value;
}

所以如果R 是E 的超类型，则将t->t 或Function.identity() 作为cast 参数传递就足够了。但它也允许R 和E 之间不存在关系的更多用例。