将 Stream<T> 映射到正在计数的 Map<T, Long>？

Question

我有一个Stream<T>，是否可以生成一个Map<T, Long>，为每个元素增加一个计数？我还想知道它是否可以将T, Long 反转为Long, T，然后将其存储在Map 中，例如输入/输出：

Stream<String>的示例内容：

kgj
def
dgh

第一个问题想要的输出：

(kgj, 1)
(def, 2)
(dgh, 3)

最终想要的输出：

(1, kgj)
(2, def)
(3, dgh)

到目前为止我所拥有的，Stream<VertexData>：

    primitives.stream()
            .flatMap(primitive -> primitive.getVertexData().stream())
            .distinct()
            .collect(Collectors.groupingBy(i -> i, Collectors.counting()))
            .forEach((k, v) -> System.out.println("k = " + k + " / v = " + v));

目前这会将Stream<Primitive> 转换为具有不同元素的Stream<VertexData>，然后转换为计算出现次数的Map<VertexData, Long>，这不是我想要的，因为我希望它继续计数通过的每个元素。

有没有办法按我的要求做？

Answer 1

您可以做的是编写自己的Collector，它会为您计算遇到的元素。类似以下的工作：

  Stream<String> strings = Stream.of("kgj", "def", "dgh");

  strings.distinct().collect(Collector.of(
          HashMap::new,
          (BiConsumer<Map<String, Long>, String>) (map, str) -> {
            map.put(str, Long.valueOf(map.size() + 1));
          },
          (left, right) -> {
            long s = left.size();
            right.entrySet().forEach(e -> left.put(e.getKey(),
                                                   Long.valueOf(
                                                           e.getValue()
                                                                   .longValue()
                                                           + s)));
            return left;
          })).forEach((k, v) -> System.out.println("k = " + k + " / v = " + v));

请注意（有些复杂的）组合器（Collector.of() 的第三个参数在并行处理流的情况下是必需的）。

Answer 2

受@jpvee 的启发，我做了一个Collector，它回答了问题的最后一个子问题，并打算更清楚一些：

public static <T> Collector<T, ?, Map<Long, T>> indexing() {
    return Collector.of(
            HashMap::new,
            (map, t) -> map.put(Long.valueOf(map.size() + 1), t),
            (left, right) -> {
                final long size = left.size();
                right.forEach((k, v) -> left.put(k + size, v));
                return left;
            },
            Collector.Characteristics.CONCURRENT
    );
}

这是做什么的：

• 在Stream<T> 上操作，它返回一个Map<Long, T>，该T 以流的遇到顺序为索引。
• 它使用Collector.of，在正常情况下接受以下内容：
  • Map 的供应商。
  • 一个累加器，将一个元素添加到Map。
  • 一个组合器，它结合了可能来自并发访问的两个Maps。
  • 特性列表。

所以我提供的是：

• Supplier<R>：一个新的HashMap。
• BiConsumer<R, T>：获取地图并添加新元素的函数。
• BinaryOperator<R>：结合两张地图的函数。
• Collector.Charasteristics：该方法的特性，允许并发执行。