Java案例怎么取集合差集？

本文目录导读：

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

在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);
    }
}

性能比较与建议

完整示例：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]
    }
}

最佳实践建议

1. 优先使用 removeAll()：对于大多数场景，这是最简单高效的方法
2. 注意不修改原集合：如果不想修改原集合，创建副本再操作
3. 大数据量优化：对于大数据量的差集计算，使用 HashSet 可以提高查询性能
4. 考虑元素排序：如果使用 TreeSet，还可以保持元素的有序性

选择哪种方法取决于你的具体需求：是否修改原集合、是否使用第三方库、数据量大小等因素。