Java案例如何取集合并集？

本文目录导读：

1. 使用 addAll() 方法（最基础）
2. 使用 Stream API（Java 8+）
3. 使用 Apache Commons Collections
4. 自定义通用方法（支持任意集合类型）
5. 保留重复元素的并集（多重集）
6. 性能优化建议

在Java中，取两个集合的并集有多种方法，具体取决于你使用的集合类型和业务需求,以下是几种最常用的实现方式：

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

import java.util.*;
public class UnionExample {
    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<String> union = new HashSet<>(set1);
        union.addAll(set2);
        System.out.println("并集: " + union); // [A, B, C, D, E]
    }
}

使用 Stream API（Java 8+）

import java.util.*;
import java.util.stream.*;
public class StreamUnionExample {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
        List<Integer> list2 = Arrays.asList(3, 4, 5, 6);
        // 使用 Stream 的 concat
        List<Integer> union = Stream.concat(list1.stream(), list2.stream())
                                   .distinct()
                                   .collect(Collectors.toList());
        System.out.println("并集: " + union); // [1, 2, 3, 4, 5, 6]
    }
}

使用 Apache Commons Collections

需要添加依赖：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.4</version>
</dependency>

import org.apache.commons.collections4.CollectionUtils;
import java.util.*;
public class CommonsUnionExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("A", "B", "C");
        List<String> list2 = Arrays.asList("B", "C", "D");
        // 返回一个新的集合
        Collection<String> union = CollectionUtils.union(list1, list2);
        System.out.println("并集: " + union); // [A, B, C, D]
    }
}

自定义通用方法（支持任意集合类型）

import java.util.*;
import java.util.function.Supplier;
import java.util.stream.Collectors;
public class GenericUnionExample {
    // 通用并集方法
    @SuppressWarnings("unchecked")
    public static <T> Collection<T> union(Collection<T> col1, Collection<T> col2) {
        Set<T> result = new HashSet<>(col1);
        result.addAll(col2);
        return result;
    }
    // 返回指定类型的集合
    public static <T, C extends Collection<T>> C union(
            Collection<T> col1, 
            Collection<T> col2, 
            Supplier<C> collectionFactory) {
        C result = collectionFactory.get();
        result.addAll(col1);
        result.addAll(col2);
        return result;
    }
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1, 2, 3);
        List<Integer> list2 = Arrays.asList(3, 4, 5);
        // 返回 Set
        Collection<Integer> union1 = union(list1, list2);
        System.out.println("Set 并集: " + union1);
        // 返回 ArrayList
        ArrayList<Integer> union2 = union(list1, list2, ArrayList::new);
        System.out.println("List 并集: " + union2);
        // 返回 LinkedHashSet (保持插入顺序)
        LinkedHashSet<Integer> union3 = union(list1, list2, LinkedHashSet::new);
        System.out.println("LinkedHashSet 并集: " + union3);
    }
}

保留重复元素的并集（多重集）

import java.util.*;
import java.util.stream.Collectors;
public class MultisetUnionExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("A", "A", "B", "C");
        List<String> list2 = Arrays.asList("A", "B", "C", "C");
        // 合并所有元素（包含重复）
        List<String> unionWithDuplicates = new ArrayList<>(list1);
        unionWithDuplicates.addAll(list2);
        System.out.println("含重复的并集: " + unionWithDuplicates);
        // [A, A, B, C, A, B, C, C]
        // 使用 Guava 的 Multiset（需要引入 Guava 库）
        // Multiset<String> multiset = HashMultiset.create();
        // multiset.addAll(list1);
        // multiset.addAll(list2);
    }
}

性能优化建议

import java.util.*;
public class PerformanceUnionExample {
    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"));
        // 预估容量: set1.size() + set2.size()
        Set<String> union = new HashSet<>(set1.size() + set2.size());
        union.addAll(set1);
        union.addAll(set2);
        System.out.println("并集: " + union);
    }
}

选择建议：

• 简单需求使用 addAll()
• Java 8+ 项目可以使用 Stream API
• 大型项目推荐使用 Apache Commons Collections
• 需要特定集合类型时使用自定义方法