Java案例如何合并集合数据？

本文目录导读：

1. 使用 addAll() 方法（最基础）
2. 使用 Stream API（Java 8+）
3. 合并Map
4. 合并自定义对象List
5. 实战：合并多个数据源

在Java中合并集合数据有多种方式,下面我会详细介绍几种常见的方法，并给出实际的代码案例。

使用 addAll() 方法（最基础）

这是最直接的方法,适用于将多个集合合并到一个集合中。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class MergeExample {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>(Arrays.asList("A", "B", "C"));
        List<String> list2 = new ArrayList<>(Arrays.asList("D", "E", "F"));
        // 创建新集合来存放合并结果
        List<String> merged = new ArrayList<>();
        merged.addAll(list1);
        merged.addAll(list2);
        System.out.println("合并后：" + merged);  // [A, B, C, D, E, F]
    }
}

使用 Stream API（Java 8+）

Stream API提供了更灵活、更函数式的合并方式。

合并两个List

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamMergeExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("A", "B", "C");
        List<String> list2 = Arrays.asList("D", "E", "F");
        List<String> list3 = Arrays.asList("G", "H");
        // 合并多个集合
        List<String> merged = Stream.of(list1, list2, list3)
                .flatMap(Collection::stream)
                .collect(Collectors.toList());
        System.out.println("合并后：" + merged);
    }
}

合并Set（去重）

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class SetMergeExample {
    public static void main(String[] args) {
        Set<String> set1 = new HashSet<>(Arrays.asList("A", "B", "C"));
        Set<String> set2 = new HashSet<>(Arrays.asList("B", "C", "D", "E"));
        // 合并Set会自动去重
        Set<String> merged = Stream.of(set1, set2)
                .flatMap(Collection::stream)
                .collect(Collectors.toSet());
        System.out.println("合并后（去重）：" + merged);  // [A, B, C, D, E]
    }
}

合并Map

Map的合并稍微复杂一些,需要考虑key冲突的处理。

简单合并（后覆盖前）

import java.util.*;
public class MapMergeExample {
    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);  // key重复
        map2.put("C", 4);
        // 方法1：使用putAll（后覆盖前）
        Map<String, Integer> merged = new HashMap<>(map1);
        merged.putAll(map2);
        System.out.println("合并后：" + merged);  // {A=1, B=3, C=4}
    }
}

使用merge方法处理key冲突

import java.util.*;
public class MapMergeWithConflict {
    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);
        // 使用merge方法，自定义冲突处理逻辑
        Map<String, Integer> merged = new HashMap<>(map1);
        map2.forEach((key, value) -> 
            merged.merge(key, value, Integer::sum)  // 重复key时相加
        );
        System.out.println("合并后（值相加）：" + merged);  // {A=1, B=5, C=4}
    }
}

合并自定义对象List

合并对象列表时,常常需要根据某个字段进行去重。

import java.util.*;
import java.util.stream.Collectors;
class Person {
    private int id;
    private String name;
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public int getId() { return id; }
    public String getName() { return name; }
    @Override
    public String toString() {
        return "Person{" + "id=" + id + ", name='" + name + '\'' + '}';
    }
}
public class ObjectMergeExample {
    public static void main(String[] args) {
        List<Person> list1 = Arrays.asList(
            new Person(1, "张三"),
            new Person(2, "李四")
        );
        List<Person> list2 = Arrays.asList(
            new Person(2, "李四（更新）"),  // id重复
            new Person(3, "王五")
        );
        // 根据id去重，保留后面的对象
        Map<Integer, Person> mergedMap = new HashMap<>();
        list1.forEach(p -> mergedMap.put(p.getId(), p));
        list2.forEach(p -> mergedMap.put(p.getId(), p));  // 后面的覆盖前面的
        List<Person> merged = new ArrayList<>(mergedMap.values());
        System.out.println("合并后（根据id去重）：");
        merged.forEach(System.out::println);
        // 输出：Person{id=1, name='张三'}
        //       Person{id=2, name='李四（更新）'}
        //       Person{id=3, name='王五'}
    }
}

实战：合并多个数据源

实际项目中经常遇到从不同数据源获取数据需要合并的情况。

import java.util.*;
import java.util.stream.Collectors;
public class MultiSourceMergeExample {
    // 模拟从数据库获取数据
    private static List<String> getFromDatabase() {
        return Arrays.asList("数据A", "数据B", "数据C");
    }
    // 模拟从缓存获取数据
    private static List<String> getFromCache() {
        return Arrays.asList("数据B", "数据D", "数据E");
    }
    // 模拟从外部API获取数据
    private static List<String> getFromExternalAPI() {
        return Arrays.asList("数据F", "数据G");
    }
    public static void main(String[] args) {
        // 从多个数据源获取数据
        List<String> databaseData = getFromDatabase();
        List<String> cacheData = getFromCache();
        List<String> apiData = getFromExternalAPI();
        // 合并所有数据并去重
        List<String> mergedData = Stream.of(databaseData, cacheData, apiData)
                .flatMap(Collection::stream)
                .distinct()  // 去重
                .collect(Collectors.toList());
        System.out.println("合并后的数据：" + mergedData);
        // [数据A, 数据B, 数据C, 数据D, 数据E, 数据F, 数据G]
    }
}

建议：

• 如果只是简单合并,使用 addAll() 即可
• 如果涉及多个集合或需要去重处理,优先使用 Stream API
• 合并Map时,注意处理key冲突的策略