如何连接两个Java流，同时为不包含重复项的项指定特定逻辑？

Question

我有两张地图使用同一个对象作为关键点。我想按键合并这两个流。当两个映射中都存在一个键时，我希望生成的映射运行一个公式。当一个键存在于单个映射中时，我希望该值为0。

Map<MyKey, Integer> map1;
Map<MyKey, Integer> map2;

<Map<MyKey, Double> result =
    Stream.concat(map1.entrySet().stream(), map2.entrySet().stream())
        .collect(Collectors.toMap(
            Map.Entry::getKey, Map.Entry::getValue,
            (val1, val2) -> (val1 / (double)val2) * 12D));

如果键存在于两个映射中，这将使用公式，但我需要一个简单的方法来将仅存在于两个映射之一中的键的值设置为0D。

我可以通过做集合数学，尝试计算两个键集的内部连接，然后从它们的完全外部连接中减去内部连接结果来实现这一点。。。但这是很多感觉不必要的工作。

有没有更好的方法，或者我可以使用流式应用编程接口轻松完成的事情？

Answer 1

Stream.concat在这里不是正确的方法，因为您将两个地图的元素扔在一起，因此需要在之后将它们分开。

您可以通过直接执行处理键的交集的预期任务来简化这一点，方法是应用您的函数并以不同的方式处理其他键。例如，当您流式传输一个地图而不是两个地图的连接时，您只需检查另一个地图中是否存在应用函数或使用零。然后，只存在于第二个映射中的键需要在第二个步骤中被归零：

Map<MyKey, Double> result = map1.entrySet().stream()
    .collect(Collectors.collectingAndThen(
        Collectors.toMap(Map.Entry::getKey, e -> {
            Integer val2 = map2.get(e.getKey());
            return val2==null? 0.0: e.getValue()*12.0/val2;
        }),
        m -> {
            Map<MyKey, Double> rMap = m.getClass()==HashMap.class? m: new HashMap<>(m);
            map2.keySet().forEach(key -> rMap.putIfAbsent(key, 0.0));
            return rMap;
        }));

这显然是因为流不能提供方便的方法来处理地图条目。此外，我们还必须在第二个处理步骤中处理未指定的映射类型。如果我们提供了一个地图供应商，我们还必须提供一个合并函数，使代码更加冗长。

更简单的解决方案是使用集合API而不是流API：

Map<MyKey, Double> result = new HashMap<>(Math.max(map1.size(),map2.size()));
map2.forEach((key, value) -> result.put(key, map1.getOrDefault(key, 0)*12D/value));
map1.keySet().forEach(key -> result.putIfAbsent(key, 0.0));

这显然不那么冗长，而且可能更有效，因为它省略了Stream解决方案的一些处理步骤，并为映射提供了正确的初始容量。它利用了这样一个事实，即如果我们在第一个映射的缺省值中使用零作为缺省值，则公式的计算结果为所需的零。如果您想使用不具有此属性的不同公式，或者想避免计算缺失映射，则必须使用

Map<MyKey, Double> result = new HashMap<>(Math.max(map1.size(),map2.size()));
map2.forEach((key, value2) -> {
    Integer value1 = map1.get(key);
    result.put(key, value1 != null? value1*12D/value2: 0.0);
});
map1.keySet().forEach(key -> result.putIfAbsent(key, 0.0));

Answer 2

为了使这个解决方案工作，您的初始映射应该是Map

你甚至不需要流！您只需使用Map#replaceAll即可修改Map中的一个：

map1.replaceAll((k, v) -> map2.containsKey(k) ? 12D * v / map2.get(k) : 0D);

现在，您只需要将每个键添加到map2中的map1，而不是map1：

map2.forEach((k, v) -> map1.putIfAbsent(k, 0D));

如果您不想修改Maps中的任何一个，那么您应该首先创建map1的深度副本。

Answer 3

这里有一个简单的方法，只流式处理键，然后查找值，并保持原始映射不变。

Map<String, Double> result =
    Stream.concat(map1.keySet().stream(), map2.keySet().stream())
          .distinct()
          .collect(Collectors.toMap(k -> k, k -> map1.containsKey(k) && map2.containsKey(k)
                                                 ? map1.get(k) * 12d / map2.get(k) : 0d));

测试

Map<String, Integer> map1 = new HashMap<>();
Map<String, Integer> map2 = new HashMap<>();
map1.put("A", 1);
map1.put("B", 2);
map2.put("A", 3);
map2.put("C", 4);
// code above here
result.entrySet().forEach(System.out::println);

输出

A=4.0
B=0.0
C=0.0