Java List集合取交集的八种不同实现方式

在Java编程中，List集合是一个非常常用的数据结构。在某些情况下，我们可能需要从两个或多个集合中获取它们的交集。交集是指同时存在于两个集合中的元素。下面我们将介绍八种不同的实现方式来获取Java中List集合的交集，并给出相应的代码示例。

1. 使用 retainAll 方法

List接口有一个内置的方法retainAll(Collection c)，可以直接用来获得交集。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class RetainAllExample {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));
        List<String> list2 = new ArrayList<>(Arrays.asList("C", "D", "E", "F"));

        list1.retainAll(list2);
        System.out.println(list1);  // 输出: [C, D]
    }
}

2. 使用 for 循环

通过遍历一个集合并检查其元素是否在另一个集合中，可以手动实现交集操作。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ForLoopExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("A", "B", "C", "D");
        List<String> list2 = Arrays.asList("C", "D", "E", "F");
        List<String> intersection = new ArrayList<>();

        for (String item : list1) {
            if (list2.contains(item)) {
                intersection.add(item);
            }
        }
        System.out.println(intersection);  // 输出: [C, D]
    }
}

3. 使用 Stream API

在Java 8及以上版本中，可以使用Stream API来简化交集的代码。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("A", "B", "C", "D");
        List<String> list2 = Arrays.asList("C", "D", "E", "F");

        List<String> intersection = list1.stream()
            .filter(list2::contains)
            .collect(Collectors.toList());

        System.out.println(intersection);  // 输出: [C, D]
    }
}

4. 使用 HashSet 集合

利用HashSet的快速查找特性，可以提升查找效率。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("A", "B", "C", "D");
        List<String> list2 = Arrays.asList("C", "D", "E", "F");

        Set<String> set = new HashSet<>(list2);
        List<String> intersection = new ArrayList<>();

        for (String item : list1) {
            if (set.contains(item)) {
                intersection.add(item);
            }
        }
        System.out.println(intersection);  // 输出: [C, D]
    }
}

5. 使用 Commons Collections

Apache Commons Collections提供了CollectionUtils工具类，可以方便地找到两个集合的交集。

import org.apache.commons.collections4.CollectionUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class CommonsCollectionsExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("A", "B", "C", "D");
        List<String> list2 = Arrays.asList("C", "D", "E", "F");

        List<String> intersection = new ArrayList<>(CollectionUtils.intersection(list1, list2));
        System.out.println(intersection);  // 输出: [C, D]
    }
}

6. 使用 Guava 库

Google的Guava库也提供了相似的功能，通过Sets.intersection方法。

import com.google.common.collect.Sets;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class GuavaExample {
    public static void main(String[] args) {
        Set<String> set1 = new HashSet<>(Arrays.asList("A", "B", "C", "D"));
        Set<String> set2 = new HashSet<>(Arrays.asList("C", "D", "E", "F"));

        Set<String> intersection = Sets.intersection(set1, set2);
        System.out.println(intersection);  // 输出: [C, D]
    }
}

7. 使用递归算法（不推荐，但可以用于学习）

递归方法求解交集，虽然不常用，但却是一个有趣的实现方式。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class RecursiveExample {
    public static List<String> getIntersection(List<String> list1, List<String> list2) {
        if (list1.isEmpty() || list2.isEmpty()) {
            return new ArrayList<>();
        }

        String head = list1.get(0);
        List<String> intersection = getIntersection(list1.subList(1, list1.size()), list2);
        if (list2.contains(head)) {
            intersection.add(0, head);
        }
        return intersection;
    }

    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("A", "B", "C", "D");
        List<String> list2 = Arrays.asList("C", "D", "E", "F");

        List<String> intersection = getIntersection(list1, list2);
        System.out.println(intersection);  // 输出: [C, D]
    }
}

8. 使用集合的并行流（Java 8及以上）

利用parallelStream来并行处理，提高性能（在数据量大的情况下特别有效）。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class ParallelStreamExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("A", "B", "C", "D", "E", "F");
        List<String> list2 = Arrays.asList("D", "E", "F", "G", "H");

        List<String> intersection = list1.parallelStream()
            .filter(list2::contains)
            .collect(Collectors.toList());

        System.out.println(intersection);  // 输出: [D, E, F]
    }
}

总结

以上介绍了八种不同的方式来获取Java中List集合的交集。这些方法各有优缺点，选择哪种方式主要取决于具体需求和性能考虑。在大多数情况下，使用retainAll方法或Stream API都是较为方便和高效的选择。在数据量较大的情况下，考虑使用集合的特性（如HashSet）来提高查找效率，会显著提升代码执行的性能。