使用Java Stream和List.contains()高效过滤列表元素

本文介绍如何使用java stream api结合`list.contains()`方法，从一个大列表中筛选出包含另一个参照列表中任意元素的子集。针对常见的误区，如尝试使用`string.matches()`，文章提供了简洁且高效的解决方案，并探讨了在处理大规模数据时提升性能的优化策略。

引言：基于参照列表过滤元素的需求

在Java编程中，我们经常会遇到这样的场景：有一个包含大量元素的主列表（例如testEle），需要从中筛选出那些同时也存在于另一个较小或参照列表（例如finalList）中的元素。这种需求在数据处理、权限校验或集合操作中非常普遍。例如，从用户列表中找出那些属于特定角色组的用户，或者从商品目录中筛选出库存充足的商品。

常见误区：String.matches()的局限性

在尝试解决这类问题时，一些开发者可能会考虑使用String.matches()方法，尤其是在处理字符串类型元素时。然而，String.matches()是用于检查字符串是否与给定的正则表达式完全匹配的。它不适用于直接判断一个字符串是否包含在另一个字符串集合中，更不适用于非字符串类型的元素。如果尝试将参照列表中的所有元素组合成一个复杂的正则表达式，不仅代码会变得难以维护，而且性能也会受到影响，尤其是在参照列表较大时。

例如，以下尝试使用matches()的方法是不正确的，因为它期望的是一个正则表达式，而不是一个元素集合：

// 错误示范：matches()期望正则表达式，而非列表元素
// testEle.stream().filter( x -> x.matches(// 某个finalList元素))

核心解决方案：Stream.filter()结合List.contains()

Java 8引入的Stream API为集合操作提供了强大而简洁的范式。结合Stream.filter()和List.contains()方法，可以优雅地解决基于参照列表过滤元素的问题。

立即学习“Java免费学习笔记（深入）”；

1. Stream.filter(Predicate<? super T> predicate)：这是Stream API的核心操作之一，它接收一个Predicate函数式接口作为参数。Predicate是一个返回布尔值的函数，对于流中的每个元素，如果predicate返回true，则该元素会被保留下来；如果返回false，则会被过滤掉。
2. List.contains(Object o)：这是一个非常直观的方法，用于检查当前列表中是否包含指定的对象o。如果包含，则返回true；否则返回false。此方法依赖于列表中元素的equals()方法来判断相等性。

将这两者结合起来，我们可以让filter操作的predicate去调用finalList.contains(x)，从而实现过滤。

示例代码

假设我们有两个List<String>：testEle是待过滤的主列表，finalList是包含参照元素的列表。

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

public class ListFilteringExample {

    public static void main(String[] args) {
        // 待过滤的主列表
        List<String> testEle = Arrays.asList(
            "apple", "banana", "cherry", "date", "elderberry",
            "fig", "grape", "honeydew", "ice cream", "juniper"
        );

        // 参照列表
        List<String> finalList = Arrays.asList(
            "banana", "date", "grape", "kiwi", "apple"
        );

        System.out.println("原始主列表: " + testEle);
        System.out.println("参照列表: " + finalList);

        // 使用Stream.filter()和List.contains()进行过滤
        List<String> filteredList = testEle.stream()
                                           .filter(x -> finalList.contains(x))
                                           .collect(Collectors.toList());

        System.out.println("过滤后的列表: " + filteredList);
        // 预期输出: [apple, banana, date, grape]

        System.out.println("\n--- 性能优化示例 (使用HashSet) ---");
        // 当finalList非常大时，转换为HashSet可以显著提升性能
        Set<String> finalSet = new HashSet<>(finalList);

        List<String> optimizedFilteredList = testEle.stream()
                                                    .filter(x -> finalSet.contains(x))
                                                    .collect(Collectors.toList());
        System.out.println("使用HashSet优化后过滤的列表: " + optimizedFilteredList);
        // 预期输出: [apple, banana, date, grape]
    }
}

代码解释：

表单大师AI

一款基于自然语言处理技术的智能在线表单创建工具，可以帮助用户快速、高效地生成各类专业表单。

74

查看详情

• testEle.stream()：将testEle列表转换为一个流。
• .filter(x -> finalList.contains(x))：这是核心部分。对于流中的每一个元素x，都会执行finalList.contains(x)。如果finalList中包含x，则contains()返回true，x会被保留到下一个操作；否则返回false，x被丢弃。
• .collect(Collectors.toList())：将过滤后的流中的元素收集到一个新的List中。

性能考量与优化

上述解决方案在大多数情况下都是高效且可读的。然而，在特定场景下，尤其当finalList（参照列表）非常庞大时，List.contains()的性能可能会成为瓶颈。

• List.contains()的性能：对于ArrayList或LinkedList，contains()方法的平均时间复杂度是O(n)，其中n是列表的大小。这意味着，对于testEle中的每一个元素，都需要遍历finalList一次。如果testEle有M个元素，finalList有N个元素，那么总的时间复杂度将是O(M * N)。当M和N都非常大时，这可能会导致性能下降。

• 使用HashSet进行优化：为了提高contains()的查找效率，可以将finalList转换为HashSet。HashSet内部使用哈希表实现，其contains()方法的平均时间复杂度为O(1)（常数时间），远优于列表的O(N)。

  优化步骤：

  1. 将finalList转换为HashSet。这个转换操作的时间复杂度是O(N)，其中N是finalList的大小。
  2. 在filter操作中使用HashSet.contains()。

  修改后的代码已在上面的示例中给出：

  Set<String> finalSet = new HashSet<>(finalList); // O(N)
  List<String> optimizedFilteredList = testEle.stream()
                                              .filter(x -> finalSet.contains(x)) // O(1)平均
                                              .collect(Collectors.toList());

  登录后复制

  通过这种优化，总的时间复杂度变为O(N + M)，在testEle和finalList都非常大的情况下，性能提升显著。

注意事项

• 元素类型与equals()方法：List.contains()和Set.contains()都依赖于元素的equals()方法来判断对象是否相等。如果你的列表中包含自定义对象，请确保正确地重写了这些对象的equals()和hashCode()方法，否则可能会得到不正确的结果。
• 可读性与简洁性：使用Stream API的filter方法使得代码意图清晰，易于理解和维护。避免过度复杂的逻辑，保持代码的简洁性。
• 内存消耗：将List转换为HashSet会额外消耗内存。在finalList极其庞大且内存受限的情况下，需要权衡性能与内存。

总结

当需要从一个列表中过滤出包含另一个参照列表中任意元素的子集时，最简洁和高效的方法是结合Java Stream API的filter()操作和List.contains()方法。对于参照列表规模较大的场景，为了进一步提升性能，建议将参照列表转换为HashSet，利用其O(1)的查找效率。理解并正确运用这些技巧，能够帮助开发者编写出更健壮、更高效的Java代码。

以上就是使用Java Stream和List.contains()高效过滤列表元素的详细内容，更多请关注php中文网其它相关文章！