0

我有一个Stream<T>，是否可以Map<T, Long>为每个元素生成一个将计数增加一个的？我还想在将其存储在示例输入/输出之前是否可以反转T, Longto ：Long, TMap

的示例内容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));

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

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

4

2 回答 2

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()在并行处理流的情况下需要第三个参数）。

于 2014-03-06T12:40:45.530 回答
1

受@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
    );
}

这是做什么的：

  • 对 a 进行操作Stream<T>，它返回一个以流的遇到顺序为Map<Long, T>索引的 a。T
  • 它使用Collector.of，用正常的话来说接受以下内容：
    • 的供应商Map。
    • 将一个元素添加到Map.
    • 组合两个Map可能来自并发访问的组合器。
    • 特征列表。

所以我提供的是：

  • Supplier<R>: 一个新的HashMap。
  • BiConsumer<R, T>：获取地图并添加新元素的函数。
  • BinaryOperator<R>：结合两个地图的功能。
  • Collector.Charasteristics：此方法的特性，允许并发执行。
于 2014-03-06T13:39:35.670 回答