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

在 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，实现所需的功能。