使用 Java 8 lambdas/transformations 组合和展平两个 Map

Question

我有两张地图：

• Map<A, Collection<B>> mapAB
• Map<B, Collection<C>> mapBC

我想将它们转换为 Map<A, Collection<C>> mapAC，我想知道是否有一种使用 lambda 和转换的平滑方法。在我的特殊情况下，集合都是集合，但我想解决一般集合的问题。

我的一个想法是首先将这两个地图组合成一个Map<A, Map<B, Collection<C>>>，然后将其展平，但我对任何方法都持开放态度。

数据说明：B 应该只出现在与一个A 关联的值集合中，mapBC 也是如此（给定的C 仅映射到一个B）。因此，从给定的A 到给定的C 应该只有一条路径，尽管可能存在没有B -> C 映射的A -> B 映射，并且可能存在B -> C 映射没有对应的A -> B 映射。这些孤儿根本不会出现在生成的mapAC 中。

为了比较起见，这里有一个针对同一问题的纯命令式方法的示例：

Map<A, Collection<C>> mapAC = new HashMap<>();

for (Entry<A, Collection<B>> entry : mapAB.entrySet()) {
    Collection<C> cs = new HashSet<>();

    for (B b : entry.getValue()) {
        Collection<C> origCs = mapBC.get(b);
        if (origCs != null) {
            cs.addAll(origCs);
        }
    }

    if (!cs.isEmpty()) {
        mapAC.put(entry.getKey(), cs);
    }
}

Answer 1

如果第一张地图中的某些 b 不存在于第二张地图中，您没有指定要做什么，因此这可能不是您要查找的内容。

mapAB.entrySet().stream()
  .filter(e -> e.getValue().stream().anyMatch(mapBC::containsKey))
  .collect(toMap(
       Map.Entry::getKey,
       e->e.getValue().stream()
           .filter(mapBC::containsKey)
           .map(mapBC::get)
           .flatMap(Collection::stream)
           .collect(toList())
  ));

Answer 2

我不喜欢 forEach 方法，这种方法非常尴尬。更纯粹的方法可能是

mapAB.entrySet().stream()
  .flatMap(
      entryAB -> entryAB.getValue().stream().flatMap(
          b -> mapBC.getOrDefault(b, Collections.<C>emptyList())
             .stream().map(
                 c -> new AbstractMap.SimpleEntry<>(entryAB.getKey(), c))))
  // we now have a Stream<Entry<A, C>>
  .groupingBy(
     Entry::getKey,
     mapping(Entry::getValue, toList()));

...或者也许交替

mapA.entrySet().stream()
  .flatMap(
      entryAB -> entryAB.getValue().stream().map(
          b -> new AbstractMap.SimpleEntry<>(
              entryAB.getKey(), 
              mapBC.getOrDefault(b, Collections.<C>emptyList()))))
  // we now have a Stream<Entry<A, Collection<C>>>
  .groupingBy(
     Entry::getKey,
     mapping(Entry::getValue, 
       reducing(
          Collections.<C>emptyList(),
          (cs1, cs2) -> {
             List<C> merged = new ArrayList<>(cs1);
             merged.addAll(cs2);
             return merged;
          })));

Answer 3

我的StreamEx 库提供了一个EntryStream 类，它是Map.Entry 对象的流以及一些额外的方便操作。这就是我使用我的库解决这个问题的方法：

Map<A, Collection<C>> mapAC = EntryStream.of(mapAB)
    .flatMapValues(Collection::stream) // flatten values: now elements are Entry<A, B>
    .mapValues(mapBC::get) // map only values: now elements are Entry<A, Collection<C>>
    .nonNullValues() // remove entries with null values
    .flatMapValues(Collection::stream) // flatten values again: now we have Entry<A, C>
    .groupingTo(HashSet::new); // group them to Map using HashSet as value collections

由于创建了更多中间对象，这可能作为@Misha 提供的出色解决方案效率较低，但在我看来，这种方式更容易编写和理解。

Answer 4

Map<A, Collection<C>> mapC =
    mapA.entrySet().stream().collect(Collectors.toMap(
        entry -> entry.getKey(),
        entry -> entry.getValue().stream().flatMap(b -> mapB.get(b).stream())
            .collect(Collectors.toSet())));

请随意将Collectors.toSet() 替换为toList()，甚至toCollection()。

Answer 5

我实际上并不反对命令式方法。由于您将它收集到内存中，因此使用 lambdas 真的没有任何好处，除非它们导致代码更清晰。这里命令式的方法很好：

Map<A, Collection<C>> mapAC = new HashMap<>();

for (A key : mapAB.keySet()) {
    Collection<C> cs = new HashSet<>();
    mapAC.put(key, cs);

    for (B b : mapAP.get(key)) {
        cs.addAll(mapBC.get(b)==null ?  Collections.emptyList() : mapBC.get(b));
    }
} 

虽然我已将您的 if 语句内嵌为三元运算符，但我认为在 for 循环中使用键看起来更清晰。

Answer 6

这个怎么样：

    Map<A, Collection<B>> mapAB = new HashMap<>();
    Map<B, Collection<C>> mapBC = new HashMap<>();
    Map<A, Collection<C>> mapAC = new HashMap<>();

    mapAB.entrySet().stream().forEach(a -> {
        Collection<C> cs = new HashSet<>();
        a.getValue().stream().filter(b -> mapBC.containsKey(b)).forEach(b -> cs.addAll(mapBC.get(b)));
        mapAC.put(a.getKey(), cs);
    });