Java案例怎么取集合差集？

wen java案例 2026-06-09 11

本文目录导读：

Java案例怎么取集合差集？

方法1：使用 removeAll() 方法（最常用）
方法2：使用 Java 8+ Stream API
方法3：泛型工具方法
方法4：使用 Apache Commons Collections
性能比较与建议
完整示例：List 差集处理
最佳实践建议

在Java中取集合差集（A - B，即属于A但不属于B的元素）有多种方法，我来介绍几种常见的方式：

方法1：使用 `removeAll()` 方法（最常用）

import java.util.*;
public class SetDifferenceExample {
    public static void main(String[] args) {
        // 创建两个集合
        Set<Integer> setA = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
        Set<Integer> setB = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));
        // 方法1：直接使用 removeAll - 会修改原集合
        Set<Integer> diff1 = new HashSet<>(setA);
        diff1.removeAll(setB);
        System.out.println("A - B (不修改原集合): " + diff1);
        // 输出: [1, 2, 3]
        // 方法2：使用 removeAll - 直接修改原集合
        Set<Integer> diff2 = setA;  // 注意：这会修改 setA
        setA.removeAll(setB);
        System.out.println("A - B (修改原集合): " + diff2);
    }
}

方法2：使用 Java 8+ Stream API

import java.util.*;
import java.util.stream.Collectors;
public class StreamDifferenceExample {
    public static void main(String[] args) {
        Set<Integer> setA = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
        Set<Integer> setB = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));
        // 使用 Stream API
        Set<Integer> difference = setA.stream()
            .filter(element -> !setB.contains(element))
            .collect(Collectors.toSet());
        System.out.println("A - B (Stream API): " + difference);
        // 输出: [1, 2, 3]
    }
}

方法3：泛型工具方法

import java.util.*;
public class SetDifferenceUtils {
    /**
     * 通用差集计算方法
     * @param setA 集合A
     * @param setB 集合B
     * @return A - B 的差集
     */
    public static <T> Set<T> difference(Set<T> setA, Set<T> setB) {
        Set<T> result = new HashSet<>(setA);
        result.removeAll(setB);
        return result;
    }
    public static void main(String[] args) {
        Set<Integer> setA = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
        Set<Integer> setB = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));
        Set<Integer> diff = difference(setA, setB);
        System.out.println("A - B: " + diff);
        // 也可以用于字符串集合
        Set<String> strA = new HashSet<>(Arrays.asList("a", "b", "c", "d"));
        Set<String> strB = new HashSet<>(Arrays.asList("c", "d", "e"));
        Set<String> strDiff = difference(strA, strB);
        System.out.println("字符串差集: " + strDiff);
    }
}

方法4：使用 Apache Commons Collections

// 需要引入依赖：org.apache.commons:commons-collections4
import org.apache.commons.collections4.SetUtils;
import java.util.*;
public class CommonsDifferenceExample {
    public static void main(String[] args) {
        Set<Integer> setA = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
        Set<Integer> setB = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));
        // 使用 Apache Commons Collections
        Set<Integer> diff = SetUtils.difference(setA, setB);
        System.out.println("A - B (Apache Commons): " + diff);
    }
}

性能比较与建议

方法	优点	缺点	适用场景
`removeAll()`	简单直接，性能好	会修改原集合（除非新建副本）	大多数通用场景
Stream API	函数式编程，不修改原集合	性能稍差（大数据量时）	代码简洁，链式操作
Apache Commons	功能丰富，封装完善	需要额外依赖	大型项目，已有该依赖

完整示例：List 差集处理

import java.util.*;
import java.util.stream.Collectors;
public class ListDifferenceExample {
    public static <T> List<T> listDifference(List<T> listA, List<T> listB) {
        // 如果是大量数据，可以考虑使用 Set 提高查询性能
        Set<T> setB = new HashSet<>(listB);
        return listA.stream()
            .filter(element -> !setB.contains(element))
            .collect(Collectors.toList());
    }
    public static void main(String[] args) {
        List<Integer> listA = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> listB = Arrays.asList(4, 5, 6, 7, 8);
        List<Integer> diffList = listDifference(listA, listB);
        System.out.println("List差集: " + diffList);
        // 输出: [1, 2, 3]
    }
}