是什么阻止我将 Map<String, List<String>> 作为 Map<String, Collection<String>> 返回？

Question

以下代码无法编译：

  public static Map<String, Collection<String>> convert(Collection<Foo> foos) {
    return foos == null ? Maps.newHashMap()
                        : foos.stream().collect(
                            Collectors.groupingBy(
                                f -> f.getSomeEnum().name(),
                                Collectors.mapping(Foo::getVal, Collectors.toList())));
  }

除非我将返回类型更改为List：

  public static Map<String, List<String>> convert(Collection<Foo> foos) {

通常我相信我应该可以，但也许泛型会引入一些歧义？

确切的错误：

Incompatible types. Required Map<String, Collection<String>> but 'collect' was inferred to R: no instance(s) of type variable(s) A, A, A, A, A, A, D, K, R, R, T, T, T, U exist so that List<T> conforms to Collection<String>

---

我认为细节不相关，但以防万一：

Foo是这样的：

public class Foo {
  private MyEnumType someEnum;
  private String val;
  public MyEnumType getSomeEnum();
  public String getVal();
}

我正在尝试将Foos 的列表转换为由someEnum 分组的Foos、vals 的映射。

Answer 1

Map<String, List<String>> 不是Map<String, Collection<String>> 的子类型，请参阅this 了解更多信息。

您可以将返回类型声明为Map<String, ? extends Collection<String>>

Answer 2

groupingBy 和mapping 的方法签名对于下游收集器的结果类型没有差异。因此，您最终会得到 toList() 收集器的结果类型 List<T>。相比之下，toCollection 的类型参数 C extends Collection<T> 有差异，但即使没有，将 ArrayList::new 分配给 Supplier<Collection<…>> 也不会有任何问题：

public static Map<String, Collection<String>> convert(Collection<Foo> foos) {
    return foos == null? new HashMap<>(): foos.stream().collect(
        Collectors.groupingBy(f -> f.getSomeEnum().name(),
            Collectors.mapping(Foo::getVal, Collectors.toCollection(ArrayList::new))));
}

考虑到当前的实现，这与toList() 完全相同。但它不会受益于未来专门针对toList() 收集器所做的改进。另一种方法是继续使用toList()，但链接类型转换：

public static Map<String, Collection<String>> convert(Collection<Foo> foos) {
    return foos == null? new HashMap<>(): foos.stream().collect(
        Collectors.groupingBy(f -> f.getSomeEnum().name(),
            Collectors.collectingAndThen(
                Collectors.mapping(Foo::getVal, Collectors.toList()),
                c -> c)));
}

由于这是一个加宽转换，所以转换函数就像c -> c一样简单。不幸的是，底层实现不知道这个函数的琐碎性，并且会遍历结果映射的值，用应用这个函数的结果替换每个值。

这可以通过特殊的加宽收集器来解决：

public static <T,A,R extends W,W> Collector<T,A,W> wideningResult(Collector<T,A,R> original) {
    return Collector.of(original.supplier(), original.accumulator(), original.combiner(),
        original.finisher().andThen(t -> t),
        original.characteristics().toArray(new Collector.Characteristics[0]));
}

这与Collectors.collectingAndThen(original, t -> t) 基本相同，链接微不足道的加宽转换函数。但是它保留了原始收集器的特性，所以如果原始收集器具有IDENTITY_FINISH 特性，我们仍然会有它，这允许跳过整理操作，这对于groupingBy 意味着它不需要迭代在地图上应用该功能。

将其应用于实际用例会产生

public static Map<String, Collection<String>> convert(Collection<Foo> foos) {
    return foos == null? new HashMap<>(): foos.stream().collect(
        Collectors.groupingBy(f -> f.getSomeEnum().name(),
            wideningResult(Collectors.mapping(Foo::getVal, Collectors.toList()))));
}