Java 在两个映射的关键点上将两个映射迭代为第三个映射

我有两个映射，其中key为整数，value为double

我想创建第三个按键排序的映射，值将是两个映射的双精度列表

地图1：

地图2：

最终地图：

1, (90.00,0.00)
5, (75.45,322.09)
8, (76.50,11.09)
9, (0.00, 21.00)

如上所述，如果一个贴图中的一个键在另一个贴图中丢失，则另一个贴图的最终贴图中的值应默认为0.00

Map firstMap = new HashMap<Integer, Double>();
Map secondMap = new HashMap<Integer, Double>();

Map finalMap = new HashMap<Integer, List<Double>>();

firstMap.put(1, 90.00);
firstMap.put(5, 75.45);
firstMap.put(8, 76.50);

secondMap.put(4, 12.00);
secondMap.put(5, 322.09);
secondMap.put(8, 11.09);
secondMap.put(9, 21.00);

Map firstMap=newhashmap（）；
Map secondMap=newhashmap（）；
Map finalMap=newhashmap（）；
firstMap.put（190.00）；
firstMap.put（5,75.45）；
firstMap.put（876.50）；
第二张地图（4,12.00）；
第二张地图（5322.09）；
第二张地图（8,11.09）；
第二张地图（9,21.00）；

我可以使用putAll方法将所有键放入第三个贴图中。但是，如何按照我的要求设置这些值呢

谢谢你的阅读

简单地做

// Create a sorted map
Map<Integer, List<Double>> finalMap = new TreeMap<Integer, List<Double>>();

Set<Integer> keys = new HashSet<Integer>();
keys.addAll(firstMap.keySet());
keys.addAll(secondMap.keySet());
for (Integer key : keys) {
    double first  = firstMap.containsKey(key)  ? firstMap.get(key)  : 0.0;
    double second = secondMap.containsKey(key) ? secondMap.get(key) : 0.0;
    finalMap.put(key, Arrays.asList(first, second));
}

//创建已排序的映射
Map finalMap=newtreemap（）；
Set keys=new HashSet（）；
addAll（firstMap.keySet（））；
addAll（secondMap.keySet（））；
for（整数键：键）{
double first=firstMap.containsKey（键）？firstMap.get（键）：0.0；
双秒=secondMap.containsKey（键）？secondMap.get（键）：0.0；
finalMap.put（key，Arrays.asList（first，second））；
}

用番石榴它很简单

Multimap<Integer, Double> finalMultiMap = ArrayListMultimap.create();
finalMultiMap.putAll(Multimaps.forMap(firstMap));
finalMultiMap.putAll(Multimaps.forMap(secondMap));

Map<Integer, Collection<Double>> finalMap = finalMultiMap.asMap();

Multimap finalMultiMap=ArrayListMultimap.create（）；
finalMultiMap.putAll（Multimaps.forMap（firstMap））；
finalMultiMap.putAll（Multimaps.forMap（secondMap））；
Map finalMap=finalMultiMap.asMap（）；

以下代码将执行请求的操作

List<Map<Integer, Double>> originals = getOriginalLists();

Map<Integer, List<Double>> result = new HashMap<Integer, List<Double>>();
for (Map<Integer, Double> original : originals) {
    for (Map.Entry<Integer, Double> entry : original.entrySet()) {
        if (!result.containsKey(entry.getKey())) {
            result.put(entry.getKey(), new ArrayList<Double>());
        }
        result.get(entry.getKey()).add(entry.getValue());
    }
}

List originals=getOriginalLists（）；
映射结果=新的HashMap（）；
用于（地图原件：原件）{
对于（Map.Entry:original.entrySet（））{
如果（！result.containsKey（entry.getKey（）））{
put（entry.getKey（），newArrayList（））；
}
result.get（entry.getKey（））.add（entry.getValue（））；
}
}

---

它在一个映射列表中工作，因此解决方案不限于两个映射。

问题在于排序的第三个映射，因为最终映射应该是排序映射的实现，例如树映射（）

Multimap<Integer, Double> finalMultiMap = ArrayListMultimap.create();
finalMultiMap.putAll(Multimaps.forMap(firstMap));
finalMultiMap.putAll(Multimaps.forMap(secondMap));

Map<Integer, Collection<Double>> finalMap = finalMultiMap.asMap();

List<Map<Integer, Double>> originals = getOriginalLists();

Map<Integer, List<Double>> result = new HashMap<Integer, List<Double>>();
for (Map<Integer, Double> original : originals) {
    for (Map.Entry<Integer, Double> entry : original.entrySet()) {
        if (!result.containsKey(entry.getKey())) {
            result.put(entry.getKey(), new ArrayList<Double>());
        }
        result.get(entry.getKey()).add(entry.getValue());
    }
}