Java中利用函数式接口和方法引用消除Stream操作中的代码重复

public class A {
   private List<B> list;

   // 假设 list 已被初始化

   public String findCreated() {
      return list.stream()
                 // .some filter operations
                 .filter(b -> b.isCreated()) // 差异点
                 // .some mapping
                 .toString(); // 简化示例，实际可能更复杂
   }

   public String findRegistered() {
      return list.stream()
                 // .some filter operations
                 .filter(b -> b.isRegistered()) // 差异点
                 // .some mapping
                 .toString(); // 简化示例，实际可能更复杂
   }
}

public class B {
    private boolean created;
    private boolean registered;

    // 构造函数、getter/setter等省略

    public boolean isCreated() {
        return created;
    }

    public boolean isRegistered() {
        return registered;
    }
}

import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class A {
   private List<B> list;

   // 假设 list 已被初始化，例如：
   public A(List<B> list) {
       this.list = list;
   }

   /**
    * 通用的查找方法，接受一个 Predicate 作为过滤条件
    * @param filter 用于过滤 B 对象的 Predicate
    * @return 经过过滤和映射后的字符串结果
    */
   private String find(Predicate<B> filter) {
      return list.stream()
                 // .some filter operations (通用操作)
                 // 假设这里有一些通用的初始过滤或转换
                 .filter(filter) // 应用传入的动态过滤条件
                 // .some mapping (通用映射操作)
                 .map(b -> "Item: " + b.toString()) // 示例映射
                 .collect(Collectors.joining(", ")); // 示例收集
   }

   // ... B 类的定义保持不变
}

import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class A {
   private List<B> list;

   public A(List<B> list) {
       this.list = list;
   }

   private String find(Predicate<B> filter) {
      return list.stream()
                 // .some filter operations (通用操作)
                 // 假设这里有一些通用的初始过滤或转换
                 .filter(filter) // 应用传入的动态过滤条件
                 // .some mapping (通用映射操作)
                 .map(b -> "Item: " + b.toString()) // 示例映射
                 .collect(Collectors.joining(", ")); // 示例收集
   }

   /**
    * 查找所有已创建的 B 对象
    * @return 已创建对象的字符串表示
    */
   public String findCreated() {
      return find(B::isCreated); // 使用方法引用 B::isCreated 作为 Predicate
   }

   /**
    * 查找所有已注册的 B 对象
    * @return 已注册对象的字符串表示
    */
   public String findRegistered() {
      return find(B::isRegistered); // 使用方法引用 B::isRegistered 作为 Predicate
   }

   // 示例主方法，用于测试
   public static void main(String[] args) {
       List<B> bList = List.of(
           new B(true, false),
           new B(false, true),
           new B(true, true),
           new B(false, false)
       );
       A processor = new A(bList);

       System.out.println("Created Items: " + processor.findCreated());
       System.out.println("Registered Items: " + processor.findRegistered());
   }
}

// B 类的完整定义，以便示例运行
class B {
    private boolean created;
    private boolean registered;

    public B(boolean created, boolean registered) {
        this.created = created;
        this.registered = registered;
    }

    public boolean isCreated() {
        return created;
    }

    public boolean isRegistered() {
        return registered;
    }

    @Override
    public String toString() {
        return "B{created=" + created + ", registered=" + registered + '}';
    }
}