Java代码重构：利用函数式接口避免方法间微小差异导致的重复代码

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

public class A {
    private List<B> list;

    // 假设构造函数或其他初始化方法
    public A(List<B> list) {
        this.list = list;
    }

    public String findCreated() {
        return list.stream()
                   // .some filter operations (通用过滤操作)
                   .filter(b -> b.isCreated()) // 差异点：过滤条件
                   // .some mapping (通用映射操作)
                   .map(Object::toString) // 假设的映射操作
                   .collect(Collectors.joining(",")); // 假设的收集操作
    }

    public String findRegistered() {
        return list.stream()
                   // .some filter operations (通用过滤操作)
                   .filter(b -> b.isRegistered()) // 差异点：过滤条件
                   // .some mapping (通用映射操作)
                   .map(Object::toString)
                   .collect(Collectors.joining(","));
    }
}

class B {
    private boolean created;
    private boolean registered;
    private String name; // 示例字段

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

    public boolean isCreated() { return created; }
    public boolean isRegistered() { return registered; }

    @Override
    public String toString() {
        return name + " (Created: " + created + ", Registered: " + registered + ")";
    }
}

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

    /**
     * 核心私有方法，接受一个 Predicate 来定义过滤逻辑。
     * 所有通用流操作都在此方法中实现。
     *
     * @param filter 用于过滤 B 对象的 Predicate
     * @return 经过过滤和映射后的字符串结果
     */
    private String find(Predicate<B> filter) {
        return list.stream()
                   // .some filter operations (通用过滤操作，例如：)
                   // .filter(b -> b.getName() != null)
                   .filter(filter) // 应用传入的动态过滤条件
                   // .some mapping (通用映射操作，例如：)
                   .map(B::getName) // 假设的映射操作，转换为B的名称
                   .collect(Collectors.joining(", ")); // 假设的收集操作
    }

    /**
     * 查找所有已创建的 B 对象。
     * @return 已创建对象的名称字符串表示
     */
    public String findCreated() {
        return find(B::isCreated); // 使用方法引用传入 isCreated 过滤逻辑
    }

    /**
     * 查找所有已注册的 B 对象。
     * @return 已注册对象的名称字符串表示
     */
    public String findRegistered() {
        return find(B::isRegistered); // 使用方法引用传入 isRegistered 过滤逻辑
    }

    // 示例：可以轻松添加新的查找方法，例如查找既创建又注册的对象
    public String findCreatedAndRegistered() {
        return find(b -> b.isCreated() && b.isRegistered());
    }

    public static void main(String[] args) {
        List<B> bList = List.of(
            new B(true, false, "Item1"),
            new B(false, true, "Item2"),
            new B(true, true, "Item3"),
            new B(false, false, "Item4")
        );

        A processor = new A(bList);

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

// B 类保持不变
/*
class B {
    private boolean created;
    private boolean registered;
    private String name;

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

    public boolean isCreated() { return created; }
    public boolean isRegistered() { return registered; }
    public String getName() { return name; } // 添加getName方法方便示例

    @Override
    public String toString() {
        return name + " (Created: " + created + ", Registered: " + registered + ")";
    }
}
*/