跳至主要內容

24. 在Java中如何合并两个Map？有哪些不同的方法？

PangHu大约 3 分钟

在 Java 中，有多种方法可以合并两个 Map，根据具体的需求和 Java 版本的不同，开发者可以选择不同的实现方式。下面介绍几种常见的合并 Map 的方法。

方法 1: 使用 putAll() 方法

putAll() 是最简单的一种方式，将一个 Map 中的所有键值对复制到另一个 Map 中。如果两个 Map 中有相同的键，目标 Map 中的值会被覆盖。

import java.util.HashMap;
import java.util.Map;

public class MergeMapsExample {
    public static void main(String[] args) {
        Map<String, Integer> map1 = new HashMap<>();
        map1.put("A", 1);
        map1.put("B", 2);

        Map<String, Integer> map2 = new HashMap<>();
        map2.put("B", 3); // 这个值会覆盖 map1 中的 "B"
        map2.put("C", 4);

        map1.putAll(map2); // 将 map2 中的所有键值对添加到 map1 中

        System.out.println(map1); // 输出: {A=1, B=3, C=4}
    }
}
  • 优点：简单、直观。
  • 缺点：如果键冲突，目标 Map 中的值会被覆盖，不适合需要处理冲突的场景。

方法 2: 使用 merge() 方法（Java 8 及以上）

Java 8 引入了 Map 的 merge() 方法，可以更灵活地处理键冲突的情况。merge() 方法允许你为冲突的键提供一个合并函数，自定义如何处理冲突。

import java.util.HashMap;
import java.util.Map;

public class MergeMapsExample {
    public static void main(String[] args) {
        Map<String, Integer> map1 = new HashMap<>();
        map1.put("A", 1);
        map1.put("B", 2);

        Map<String, Integer> map2 = new HashMap<>();
        map2.put("B", 3); // 键 "B" 冲突
        map2.put("C", 4);

        map2.forEach((key, value) -> 
            map1.merge(key, value, (v1, v2) -> v1 + v2)); // 合并冲突的值

        System.out.println(map1); // 输出: {A=1, B=5, C=4}
    }
}
  • 优点：灵活，可以定义合并策略，如相加、取较大值等。
  • 缺点：稍微复杂一些，需要定义合并逻辑。

方法 3: 使用 compute() 方法（Java 8 及以上）

compute() 方法允许在 Map 中对现有键进行计算和更新。可以通过遍历第二个 Map，对第一个 Map 进行更新或插入。

import java.util.HashMap;
import java.util.Map;

public class MergeMapsExample {
    public static void main(String[] args) {
        Map<String, Integer> map1 = new HashMap<>();
        map1.put("A", 1);
        map1.put("B", 2);

        Map<String, Integer> map2 = new HashMap<>();
        map2.put("B", 3); // 键 "B" 冲突
        map2.put("C", 4);

        map2.forEach((key, value) -> 
            map1.compute(key, (k, v) -> (v == null) ? value : v + value));

        System.out.println(map1); // 输出: {A=1, B=5, C=4}
    }
}
  • 优点：可以对现有值进行复杂的计算和更新。
  • 缺点：相对于 merge()，compute() 的表达方式略复杂。

方法 4: 使用 Stream 和 Collectors（Java 8 及以上）

对于需要返回新的 Map 的情况，可以使用 Stream API 和 Collectors 来合并两个 Map。这种方法适合在需要合并多个 Map 并生成一个新 Map 的场景下使用。

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class MergeMapsExample {
    public static void main(String[] args) {
        Map<String, Integer> map1 = new HashMap<>();
        map1.put("A", 1);
        map1.put("B", 2);

        Map<String, Integer> map2 = new HashMap<>();
        map2.put("B", 3);
        map2.put("C", 4);

        Map<String, Integer> mergedMap = Stream.concat(map1.entrySet().stream(), map2.entrySet().stream())
            .collect(Collectors.toMap(
                Map.Entry::getKey,
                Map.Entry::getValue,
                Integer::sum // 合并冲突的值
            ));

        System.out.println(mergedMap); // 输出: {A=1, B=5, C=4}
    }
}
  • 优点：适合将多个 Map 合并到一个新的 Map 中，同时可以自定义冲突处理逻辑。
  • 缺点：相对复杂，适合熟悉 Stream API 的开发者。

方法 5: 手动迭代和合并

对于特殊场景或需要自定义逻辑的情况，可以通过手动迭代来合并 Map。

import java.util.HashMap;
import java.util.Map;

public class MergeMapsExample {
    public static void main(String[] args) {
        Map<String, Integer> map1 = new HashMap<>();
        map1.put("A", 1);
        map1.put("B", 2);

        Map<String, Integer> map2 = new HashMap<>();
        map2.put("B", 3); // 键 "B" 冲突
        map2.put("C", 4);

        for (Map.Entry<String, Integer> entry : map2.entrySet()) {
            map1.put(entry.getKey(), map1.getOrDefault(entry.getKey(), 0) + entry.getValue());
        }

        System.out.println(map1); // 输出: {A=1, B=5, C=4}
    }
}
  • 优点：完全控制合并过程，灵活性高。
  • 缺点：代码冗长，容易出错。

总结

  • putAll()：简单直接，用于不关心键冲突的情况，目标 Map 的值会被覆盖。
  • merge()：适合在合并过程中需要处理键冲突的场景，允许自定义合并逻辑。
  • compute()：适合复杂的键冲突处理和计算逻辑。
  • Stream + Collectors：适合将多个 Map 合并到新的 Map 中，灵活且功能强大。
  • 手动迭代：适用于需要完全自定义合并逻辑的特殊情况。

根据具体需求选择合适的方法，可以帮助你更高效地合并 Map，实现所需的功能。