Java Stream中利用函数式参数实现数据去重与过滤

本文深入探讨了java stream api中`filter`方法与函数式参数的结合使用。通过分析一个具体的代码示例，我们将理解如何利用`predicate`和`function`来高效地从集合中筛选出基于特定属性的唯一元素，并揭示了其内部执行机制，包括`predicate`的生成与逐元素应用过程，以及如何通过状态管理实现去重逻辑。

理解Java Stream与filter操作

Java Stream API是Java 8引入的一项强大特性，它提供了一种声明式处理数据集合的管道化方式。filter是Stream中最常用的中间操作之一，它接收一个Predicate函数式接口作为参数，并返回一个只包含满足该Predicate条件的元素的新Stream。Predicate是一个函数式接口，定义了一个抽象方法test(T t)，该方法接受一个类型为T的参数并返回一个boolean值。

Function与Predicate：函数式接口的协同

在Java中，Function<T, R>和Predicate<T>是两个核心的函数式接口。

• Function<T, R>：接受一个类型T的参数，并返回一个类型R的结果。例如，Person::getName就是一个Function<Person, String>，它接收一个Person对象并返回其姓名（String）。
• Predicate<T>：接受一个类型T的参数，并返回一个boolean结果。它常用于过滤操作。

在提供的示例代码中，我们看到checkMethod方法巧妙地结合了这两个接口来实现去重逻辑。

import java.util.List;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;

public class StreamUniqueExample {

  public static void main(String[] args) {
    Person p1 = new Person("test1");
    Person p2 = new Person("test2");
    Person p3 = new Person("test1"); // Add a duplicate for demonstration

    List<Person> l = List.of(p1, p2, p3);
    // 预期结果：p1和p2会被保留，p3（因为与p1同名）会被过滤掉
    var count = l.stream().filter(checkMethod(Person::getName)).count();
    System.out.println("Unique names count: " + count); // 应该输出 2
  }

  /**
   * 生成一个用于过滤Stream中重复元素的Predicate。
   * 该Predicate根据指定的keyExtractor提取的键值进行去重判断。
   *
   * @param keyExtractor 用于从元素中提取作为去重依据的键的Function。
   * @param <T> Stream中元素的类型。
   * @return 一个Predicate，当且仅当元素提取的键首次出现时返回true。
   */
  public static final <T> Predicate<T> checkMethod(Function<? super T, ?> keyExtractor) {
    Objects.requireNonNull(keyExtractor);
    // 使用ConcurrentHashMap.newKeySet()创建一个线程安全的Set来存储已“见过”的键
    final var seen = ConcurrentHashMap.newKeySet();
    // 返回一个Predicate，其test方法在每次调用时尝试将键添加到seen集合中。
    // Set.add()方法在元素首次添加时返回true，若元素已存在则返回false。
    return t -> seen.add(keyExtractor.apply(t));
  }
}

// Person.java (假设在同一文件或可访问的包中)
class Person {
  private String name;

  Person(String name) {
    this.name = name;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  @Override
  public String toString() {
    return "Person{" + "name='" + name + '\'' + '}';
  }
}

checkMethod的内部工作机制解析

checkMethod方法是实现去重逻辑的核心。让我们详细分解它的作用：

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

1. 方法签名：

   public static final <T> Predicate<T> checkMethod(Function<? super T, ?> keyExtractor)

   登录后复制

   它是一个泛型方法，接受一个Function作为参数，并返回一个Predicate。

   • keyExtractor：这个Function的目的是从Stream中的每个元素T中提取一个用于去重的“键”。在示例中，Person::getName被作为keyExtractor传入，它负责从Person对象中提取name字符串。
   • 返回类型Predicate<T>：这意味着checkMethod的最终产物是一个可以对T类型元素进行判断（test）并返回boolean值的功能对象。

2. 状态管理：

   final var seen = ConcurrentHashMap.newKeySet();

   登录后复制

   在checkMethod内部，创建了一个ConcurrentHashMap.newKeySet()。这是一个线程安全的Set，用于存储所有已经“见过”的、由keyExtractor提取出的键。final关键字确保seen引用在checkMethod执行期间不会改变，但seen集合本身的内容是可变的。

3. 生成Predicate：

   

   怪兽AI数字人

   数字人短视频创作，数字人直播，实时驱动数字人

   44

   查看详情

   return t -> seen.add(keyExtractor.apply(t));

   登录后复制

   这是checkMethod最关键的部分。它返回一个Lambda表达式，这个Lambda表达式实际上就是一个Predicate<T>的实例。

   • t：代表Stream中的当前元素（例如，一个Person对象）。
   • keyExtractor.apply(t)：调用传入的keyExtractor（例如Person::getName），从当前元素t中提取出用于去重的键（例如"test1"）。
   • seen.add(...)：尝试将提取出的键添加到seen集合中。Set.add()方法的行为至关重要：
     • 如果该键是第一次被添加到seen集合中，add()方法会成功添加并返回true。
     • 如果该键已经存在于seen集合中，add()方法不会重复添加，并返回false。

Stream执行流程详解

现在，我们结合main方法中的调用来理解整个Stream的执行过程：

1. checkMethod的首次调用（Predicate生成阶段）：

   l.stream().filter(checkMethod(Person::getName))

   登录后复制

   在Stream管道开始处理元素之前，checkMethod(Person::getName)会被立即且仅调用一次。这次调用会：

   • 创建一个空的ConcurrentHashMap.newKeySet()，并将其引用赋值给seen变量。
   • 返回一个Lambda表达式t -> seen.add(keyExtractor.apply(t))，这个Lambda表达式就是filter方法所期望的Predicate实例。
   • 请注意，此时Stream中的任何元素都尚未被处理。

2. filter方法的逐元素应用（Predicate执行阶段）： 当Stream开始处理元素时，filter方法会遍历Stream中的每个Person对象，并对每个对象调用步骤1中生成的那个Predicate实例的test方法。

   • 处理 p1 (Person("test1"))：

     • keyExtractor.apply(p1) 返回 "test1"。
     • seen.add("test1")：seen集合中尚无"test1"，所以"test1"被添加到seen中，add()返回true。
     • filter接收到true，因此p1被保留在Stream中。

   • 处理 p2 (Person("test2"))：

     • keyExtractor.apply(p2) 返回 "test2"。
     • seen.add("test2")：seen集合中尚无"test2"，所以"test2"被添加到seen中，add()返回true。
     • filter接收到true，因此p2被保留在Stream中。

   • 处理 p3 (Person("test1"))：

     • keyExtractor.apply(p3) 返回 "test1"。
     • seen.add("test1")：seen集合中已经有"test1"了，所以add()方法不会再次添加，并返回false。
     • filter接收到false，因此p3被从Stream中过滤掉。

3. count终端操作：count()方法统计经过filter操作后Stream中剩余的元素数量。在本例中，p1和p2被保留，所以最终计数为2。

注意事项与总结

• Predicate的生命周期： checkMethod只执行一次，生成一个Predicate实例。这个Predicate实例内部维护着一个seen集合，并在Stream处理过程中反复被调用。
• 状态共享： seen集合是Predicate实例的内部状态。由于filter操作是逐元素进行的，这个seen集合能够正确地记录所有已经处理过的键，从而实现去重。
• 线程安全： 示例中使用了ConcurrentHashMap.newKeySet()来创建seen集合，这使得即使在并行Stream（l.parallelStream()）中使用此Predicate，去重逻辑也能保持线程安全。
• 通用性： 这种模式非常通用，可以用于基于任何属性（通过keyExtractor指定）对Stream中的对象进行去重。
• 惰性求值： Stream操作是惰性求值的。filter操作本身并不会立即处理所有元素，而是在遇到终端操作（如count()、collect()等）时，才会驱动整个管道的执行。

通过上述分析，我们清晰地理解了Java Stream中filter方法如何与自定义的Predicate以及Function参数协同工作，从而高效且优雅地实现了基于特定属性的元素去重功能。这种模式充分体现了函数式编程在Java中的强大表现力。

以上就是Java Stream中利用函数式参数实现数据去重与过滤的详细内容，更多请关注php中文网其它相关文章！