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

解决方案：利用函数式接口抽象行为

为了解决这种重复问题，我们可以将方法中变化的逻辑（即过滤条件）作为参数传递给一个公共的辅助方法。Java 8引入的函数式接口为实现这一目标提供了强大的支持。

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

核心思想： 识别出重复代码中的变化点，将其封装为一个函数式接口的实例，然后将该实例作为参数传递给一个包含通用逻辑的私有（或受保护）方法。

Predicate 函数式接口： 在Java标准库中，java.util.function.Predicate是一个非常适合处理过滤条件的函数式接口。它定义了一个抽象方法boolean test(T t)，接收一个类型为T的参数并返回一个布尔值。这完美契合了我们的需求：判断一个B对象是否满足某个条件。

重构步骤：

LALALAND

AI驱动的时尚服装设计平台

下载

1. 识别变化点： 在本例中，变化点是filter()方法内部的Lambda表达式b -> b.isCreated()和b -> b.isRegistered()。
2. 创建辅助方法： 定义一个私有方法，例如find(Predicate filter)，它将接收一个Predicate作为参数。
3. 迁移通用逻辑： 将findCreated()和findRegistered()中重复的流操作逻辑（list.stream().some filter operations.some mapping.collect(...)）迁移到新的find()辅助方法中。
4. 应用参数化过滤： 在辅助方法中，使用传入的Predicate参数来执行过滤操作，即stream.filter(filter)。
5. 调用辅助方法： 修改原始的findCreated()和findRegistered()方法，使其调用新的find()辅助方法，并传入具体的过滤逻辑（使用Lambda表达式或方法引用）。

重构实践与示例代码

按照上述步骤，我们可以将A类重构如下：

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

public class A {
    private List list;

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

    /**
     * 核心私有方法，接受一个 Predicate 来定义过滤逻辑。
     * 所有通用流操作都在此方法中实现。
     *
     * @param filter 用于过滤 B 对象的 Predicate
     * @return 经过过滤和映射后的字符串结果
     */
    private String find(Predicate 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 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 + ")";
    }
}
*/

在上述重构后的代码中，find(Predicate filter)方法封装了所有通用的流操作逻辑。findCreated()和findRegistered()现在只需调用这个辅助方法，并分别传入B::isCreated和B::isRegistered作为Predicate的实现。这里的B::isCreated和B::isRegistered是方法引用，它们是Lambda表达式b -> b.isCreated()和b -> b.isRegistered()的简洁形式。