使用通配符类型减少流

我正在尝试Stream.reduce()，并且遇到了类型系统的障碍。这是一个玩具示例：

public static Number reduceNum1(List<Number> nums) {
  return nums.stream().reduce(0, (a, b) -> a);
}

这适用于任何List<Number>，但是如果我希望能够减少一个列表，该怎么办? extends Number？这不能编译：

public static Number reduceNum2(List<? extends Number> nums) {
    return nums.stream().reduce((Number)0, (a, b) -> a);
}

出现错误：

ReduceTest.java:72: error: no suitable method found for reduce(Number,(a,b)->a)
        return nums.stream().reduce((Number)0, (a, b) -> a);
                            ^
    method Stream.reduce(CAP#1,BinaryOperator<CAP#1>) is not applicable
      (argument mismatch; Number cannot be converted to CAP#1)
    method Stream.<U>reduce(U,BiFunction<U,? super CAP#1,U>,BinaryOperator<U>) is not applicable
      (cannot infer type-variable(s) U
        (actual and formal argument lists differ in length))
  where U,T are type-variables:
    U extends Object declared in method <U>reduce(U,BiFunction<U,? super T,U>,BinaryOperator<U>)
    T extends Object declared in interface Stream
  where CAP#1 is a fresh type-variable:
    CAP#1 extends Number from capture of ? extends Number
Note: Some messages have been simplified; recompile with -Xdiags:verbose to get full output

从概念上讲，我明白为什么会发生这种情况。Stream.reduce()必须返回与源元素类型相同的内容，并且? extends Number不等于Number。但我不确定如何处理这个案子。我如何允许子类的集合（例如List<Integer>）减少（或收集）？

如果有帮助的话，这里有一个更实际的例子，同样无法编译：

public static <E> Set<E> reduceSet1(List<? extends Set<E>> sets) {
  return sets.stream().reduce(ImmutableSet.<E>of(), (a, b) -> Sets.union(a, b));
}

问题实际上并不在于? extends，但随着identity参数为reduce()。正如 Sotirios Delimanolis 建议的那样，您可以指定有界类型N extends Number，但前提是身份值为null.

public static <N extends Number> N reduceNum3(List<N> nums) {
  return nums.stream().reduce(null, (a, b) -> a);
}

这是因为通配符和有界方法都无法确定标识参数是否与列表元素的类型相同（除非它是null，所有类型共享）。

解决方法是使用三参数reduce()方法，它允许您将结果视为不同的类型（即使它不是really).

这是Number例子：

public static Number reduceNum4(List<? extends Number> nums) {
  return nums.stream().reduce((Number)0,
    (a, b) -> a,
    (a, b) -> a);
}

这是Set例子：

public static <E> Set<E> reduceSet2(List<? extends Set<E>> sets) {
  return sets.stream().<Set<E>>reduce(
      ImmutableSet.<E>of(), Sets::union, Sets::union);
}

有点烦人的是，你必须重复减少功能，因为accumulator和combiner是不同的类型。您大概可以在变量中定义一次，然后通过不安全的强制转换将其传递给两者，但我不太确定这是一种改进。无论如何，使用方法引用可能是正确的方法。