你可以使用HashMap<String, List<Integer>>来合并两个HashMap，避免丢失与相同键配对的元素。

HashMap<String, Integer> map1 = new HashMap<>();
HashMap<String, Integer> map2 = new HashMap<>();
map1.put("key1", 1);
map1.put("key2", 2);
map1.put("key3", 3);
map2.put("key1", 4);
map2.put("key2", 5);
map2.put("key3", 6);
HashMap<String, List<Integer>> map3 = new HashMap<>();
map1.forEach((str, num) -> map3.put(str, new ArrayList<>(Arrays.asList(num))));
//checking for each key if its already in the map, and if so, you just add the integer to the list paired with this key
for (Map.Entry<String, Integer> entry : map2.entrySet()) {
    Integer value = entry.getValue();
    String key = entry.getKey();
    if (map3.containsKey(key)) {
        map3.get(key).add(value);
    } else {
        map3.put(key, new ArrayList<>(Arrays.asList(value)));
    }
}
map3.forEach((str, list) -> System.out.println("{" + str + ": " + list + "}"));

输出:

{key1: [1, 4]}
{key2: [2, 5]}
{key3: [3, 6]}

用于合并两个映射的Java 8替代一行程序:

defaultMap.forEach((k, v) -> destMap.putIfAbsent(k, v));

方法参考也一样:

defaultMap.forEach(destMap::putIfAbsent);

或原始地图解与第三个地图的幂分量:

Map<String, Integer> map3 = new HashMap<String, Integer>(map2);
map1.forEach(map3::putIfAbsent);

下面是一个用Guava将两个映射合并为快速不可变映射的方法，它可以进行最少的中间复制操作:

ImmutableMap.Builder<String, Integer> builder = ImmutableMap.<String, Integer>builder();
builder.putAll(map1);
map2.forEach((k, v) -> {if (!map1.containsKey(k)) builder.put(k, v);});
ImmutableMap<String, Integer> map3 = builder.build();

请参见使用Java 8合并两个映射，了解需要使用映射函数组合两个映射中的值的情况。

如果知道没有重复的键，或者希望map2中的值覆盖map1中的值以获得重复的键，那么可以只写

map3 = new HashMap<>(map1);
map3.putAll(map2);

如果需要更多地控制值的组合方式，可以使用Map。merge，在Java 8中添加，它使用用户提供的biffunction来合并重复键的值。merge操作单独的键和值，因此需要使用循环或Map.forEach。这里我们连接重复键的字符串:

map3 = new HashMap<>(map1);
for (Map.Entry<String, String> e : map2.entrySet())
    map3.merge(e.getKey(), e.getValue(), String::concat);
//or instead of the above loop
map2.forEach((k, v) -> map3.merge(k, v, String::concat));

如果你知道你没有重复的键，并且想要强制它，你可以使用merge函数抛出AssertionError:

map2.forEach((k, v) ->
    map3.merge(k, v, (v1, v2) ->
        {throw new AssertionError("duplicate values for key: "+k);}));

从这个特定的问题后退一步，Java 8流库提供了toMap和groupingBy collector。如果在循环中重复合并映射，则可以重新构造计算以使用流，这既可以澄清代码，又可以使用并行流和并发收集器轻松实现并行。

如果最终的映射不需要可变性，可以使用Guava的ImmutableMap及其Builder和putAll方法，与Java的map接口方法相反，ImmutableMap可以被链接。

使用示例:

Map<String, Integer> mergeMyTwoMaps(Map<String, Integer> map1, Map<String, Integer> map2) {
  return ImmutableMap.<String, Integer>builder()
      .putAll(map1)
      .putAll(map2)
      .build();
}

当然，这个方法可以更通用，使用可变参数和循环从参数中putAll map等，但我想展示一个概念。

此外，ImmutableMap和它的构建器有一些限制(或者可能是功能?):

他们是空敌对(抛出NullPointerException -如果map中的任何键或值为空) 生成器不接受重复的键(如果添加了重复的键则抛出IllegalArgumentException)。

一个小片段，我经常使用从其他地图创建地图:

static public <K, V> Map<K, V> merge(Map<K, V>... args) {
    final Map<K, V> buffer = new HashMap<>();

    for (Map m : args) {
        buffer.putAll(m);
    }

    return buffer;
}

map3 = new HashMap<>();

map3.putAll(map1);
map3.putAll(map2);