Unexpected Bound - 为什么我不能在这个收集器中使用 T extends Collection 之类的东西？

Question

嗨，我已经编写了这个自定义收集器，用于将元素List转换为Multimap ：

public class MultiMapCollector implements Collector<Entity,
        Map<String, Collection<String>>, Map<String, Collection<String>>> {

    @Override
    public Supplier<Map<String, Collection<String>>> supplier() {
        return HashMap::new;
    }

    @Override
    public BiConsumer<Map<String, Collection<String>>, Entity> accumulator() {
        return (map, e) -> map.computeIfAbsent(e.getName(),
                k -> new HashSet<>()).add(e.getValue());
    }

    @Override
    public BinaryOperator<Map<String, Collection<String>>> combiner() {
        return (map1, map2) -> {
            map2.keySet().forEach(key -> map1.computeIfAbsent(key, k -> new HashSet<>()).addAll(map2.get(key)));
            return map1;
        };
    }

    @Override
    public Function<Map<String, Collection<String>>, Map<String, Collection<String>>> finisher() {
        return Collections::unmodifiableMap;
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Set.of(Characteristics.UNORDERED);
    }
}

现在我希望能够传递List或Set 。

所以不是Map<String, Collection<String>>我想要Map<String, V extends Collection<String>>

但是当我这样做时，我得到一个模糊的错误说：

Unexpected Bounds

我究竟做错了什么 ？

我似乎无法解决这个问题。

Answer 1

您需要在类名之后添加一个泛型类型参数（我们称之为C ），而不是在implements子句中。

然后，添加一个接受Supplier<C>的构造函数，告诉您如何创建C ，并将供应商存储在某处。 将所有出现的new HashSet<>()替换为对供应商的get调用。

class MultiMapCollector<C extends Collection<String>> implements Collector<Entity, Map<String, C>, Map<String, C>> {

     private final Supplier<C> supplier;

     public MultiMapCollector(Supplier<C> supplier) {

         this.supplier = supplier;
     }

    @Override
    public Supplier<Map<String, C>> supplier() {
        return HashMap::new;
    }

    @Override
    public BiConsumer<Map<String, C>, Entity> accumulator() {
        return (map, e) -> map.computeIfAbsent(e.getName(),
            k -> supplier.get()).add(e.getValue());
    }

    @Override
    public BinaryOperator<Map<String, C>> combiner() {
        return (map1, map2) -> {
            map2.keySet().forEach(key -> map1.computeIfAbsent(key, k -> supplier.get()).addAll(map2.get(key)));
            return map1;
        };
    }

    @Override
    public Function<Map<String, C>, Map<String, C>> finisher() {
        return Collections::unmodifiableMap;
    }

    @Override
    public Set<Characteristics> characteristics() {
        // now you aren't sure whether the collection is ordered or not
        return Set.of();
    }
}

现在每次创建MultiMapCollector时，都需要传入一个供应商：

new MultiMapCollector<>(HashSet::new)

如果您希望它在不提供任何内容时使用默认的HashSet ，请添加静态工厂方法并将构造函数设为私有：

 public static MultiMapCollector<Set<String>> get() {
     return new MultiMapCollector<>(HashSet::new);
 }

 public static <C extends Collection<String>> MultiMapCollector<C> with(Supplier<C> supplier) {
     return new MultiMapCollector<>(supplier);
 }

就像Collectors.groupingBy是一个工厂方法一样。

更一般地说，您可以采用完整的下游收集器而不仅仅是Supplier<C> ，这就是Collectors.groupingBy的 2 参数重载所做的。 groupingBy只处理分组，下游收集器（第二个参数）处理组。

这是您如何执行此操作的草图：

class MultiMapCollector<R> implements Collector<Entity, Map<String, R>, Map<String, R>> {

     private final Collector<String, R, R> downstream;

     private MultiMapCollector(Collector<String, R, R> downstream) {

         this.downstream = downstream;
     }

     public static MultiMapCollector<Set<String>> get() {
         return new MultiMapCollector<>(Collectors.toSet());
     }

     public static <R> MultiMapCollector<R> with(Collector<String, R, R> downstream) {
         return new MultiMapCollector<>(downstream);
     }

    @Override
    public Supplier<Map<String, R>> supplier() {
        return HashMap::new;
    }

    @Override
    public BiConsumer<Map<String, R>, Entity> accumulator() {
        return (map, e) -> downstream.accumulator().accept(map.computeIfAbsent(e.getName(),
            k -> downstream.supplier().get()), e.getValue());
    }

    @Override
    public BinaryOperator<Map<String, R>> combiner() {
        return (map1, map2) -> {
            map2.keySet().forEach(key -> 
                downstream.combiner().apply(
                    map1.computeIfAbsent(key, k -> downstream.supplier().get()),
                    map2.get(key)
                )
            );
            return map1;
        };
    }

    @Override
    public Function<Map<String, R>, Map<String, R>> finisher() {
        return Collections::unmodifiableMap;
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Set.of();
    }
}

Answer 2

如果您希望允许将Collection<String>的不同实现用作地图的值，则需要为MultiMapCollector定义类型参数。 您还需要修改代码以接受某种对象，例如Supplier ，它知道如何创建特定集合类型的实例。

例如：

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;

public class MultiMapCollector<V extends Collection<String>>
    implements Collector<Entity, Map<String, V>, Map<String, V>> {

  private final Supplier<? extends V> valueSupplier;

  public MultiMapCollector(Supplier<? extends V> valueSupplier) {
    this.valueSupplier = valueSupplier;
  }

  @Override
  public Supplier<Map<String, V>> supplier() {
    return HashMap::new;
  }

  @Override
  public BiConsumer<Map<String, V>, Entity> accumulator() {
    return (map, e) -> map.computeIfAbsent(e.getName(), k -> valueSupplier.get()).add(e.getValue());
  }

  @Override
  public BinaryOperator<Map<String, V>> combiner() {
    return (map1, map2) -> {
      for (var entry : map2.entrySet()) {
        map1.merge(
            entry.getKey(),
            entry.getValue(),
            (curValue, newValue) -> {
              curValue.addAll(newValue);
              return curValue;
            });
      }
      return map1;
    };
  }

  @Override
  public Function<Map<String, V>, Map<String, V>> finisher() {
    return Collections::unmodifiableMap;
  }

  @Override
  public Set<Characteristics> characteristics() {
    return Set.of(Characteristics.UNORDERED);
  }
}

注意MultiMapCollector现在具有类型参数<V extends Collection<String>> ，并且代码中使用Collection<String>的其他任何地方都已替换为V 。 然后构造函数接受一个Supplier<? extends V> Supplier<? extends V>用于在accumulator()消费者中创建V的实例。

另外，请注意我更新了您的combiner()函数以使用Map#merge(...) ，尽管这不是绝对必要的。

---

顺便说一句，如果您想真正了解Collectors.groupingBy(...)是如何实现的，那么您可以随时查看源代码。