Java代码重构：利用Predicate消除方法中单行差异的重复代码

本文旨在探讨java中一种常见的代码重复问题：当多个方法主体结构相似，仅在某一特定逻辑（如过滤条件）上存在细微差异时。我们将通过引入java 8的函数式接口predicate，演示如何将这些差异抽象化，从而重构出简洁、可维护且易于扩展的通用方法，有效避免代码冗余。

在软件开发中，我们经常会遇到这样的场景：多个方法执行着几乎相同的业务逻辑，唯一的区别在于其中的一小部分，例如一个条件判断、一个数据转换规则或一个特定的操作。这种“几乎相同”的代码模式是代码重复的常见来源，它不仅增加了代码库的体积，更重要的是，它极大地损害了代码的可维护性、可读性和可扩展性。当需要修改或修复bug时，开发者可能需要在多个地方进行相同的改动，这无疑增加了出错的风险和维护成本。

考虑以下Java代码示例，其中A类包含两个方法findCreated()和findRegistered()，它们都对list进行流式处理，包括一些共同的过滤和映射操作，但最终的filter条件有所不同：

public class A {
   private List<B> list;

   // ... 其他成员和方法

   public String findCreated() {
      return list.stream()
                 // .some filter operations
                 .filter(b -> b.isCreated()) // 差异点
                 // .some mapping
                 .collect(Collectors.joining(",")); // 假设最终收集为字符串
   }

   public String findRegistered() {
      return list.stream()
                 // .some filter operations
                 .filter(b -> b.isRegistered()) // 差异点
                 // .some mapping
                 .collect(Collectors.joining(",")); // 假设最终收集为字符串
   }
}

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

    // ... 构造函数、getter/setter

    public boolean isCreated() {
        return created;
    }

    public boolean isRegistered() {
        return registered;
    }
}

在这个例子中，findCreated()和findRegistered()方法除了.filter(b -> b.isCreated())和.filter(b -> b.isRegistered())这一行之外，其余代码完全相同。这种重复是典型的重构目标。

解决方案：利用java.util.function.Predicate

Java 8引入的函数式接口为解决这类问题提供了强大的工具。java.util.function.Predicate<T>是一个函数式接口，它定义了一个抽象方法boolean test(T t)，用于表示一个参数的布尔值函数（即一个条件判断）。通过将变化的过滤条件抽象为Predicate，我们可以创建一个通用的私有方法来封装共享的逻辑。

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

降重鸟

要想效果好，就用降重鸟。AI改写智能降低AIGC率和重复率。

308

查看详情

重构步骤

1. 识别通用逻辑与差异点：

   • 通用逻辑：list.stream().some filter operations... .some mapping
   • 差异点：.filter(b -> b.isCreated()) 和 .filter(b -> b.isRegistered())

2. 创建通用私有方法： 定义一个私有方法，例如find(Predicate<B> filter)，该方法接受一个Predicate<B>作为参数。将所有共享的流操作放入此方法中，并在需要应用差异化过滤的地方使用传入的filter参数。

3. 重写公共方法： 修改原有的公共方法（如findCreated()和findRegistered()），使其不再包含重复的逻辑，而是简单地调用新创建的通用私有方法，并传入各自特定的Predicate实现。Java 8的方法引用（Method Reference）在这里可以极大地简化代码。例如，B::isCreated是b -> b.isCreated()的简洁形式。

示例代码

经过重构后的A类如下所示：

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对象的条件
    * @return 经过过滤和映射后的字符串结果
    */
   private String find(Predicate<B> filter) {
      return list.stream()
                 // 假设这里有一些通用的过滤操作，例如：
                 // .filter(b -> b.getSomeProperty() != null)
                 .filter(filter) // 应用传入的差异化过滤条件
                 // 假设这里有一些通用的映射操作，例如：
                 // .map(b -> b.getName())
                 .map(B::toString) // 假设将B对象转换为其字符串表示
                 .collect(Collectors.joining(",")); // 假设最终收集为逗号分隔的字符串
   }

   /**
    * 查找所有已创建的B对象。
    * @return 已创建B对象的字符串列表
    */
   public String findCreated() {
      return find(B::isCreated); // 使用方法引用传入isCreated条件
   }

   /**
    * 查找所有已注册的B对象。
    * @return 已注册B对象的字符串列表
    */
   public String findRegistered() {
      return find(B::isRegistered); // 使用方法引用传入isRegistered条件
   }
}

// B类保持不变
// public class B { ... }

收益分析

通过上述重构，我们获得了以下显著优势：

• 消除代码重复： 核心的流处理逻辑现在只存在于一个地方，即find私有方法中。
• 提高可维护性： 如果将来需要修改通用的过滤或映射逻辑，只需在一个地方进行更改，而不是在多个方法中重复操作。
• 增强可读性： 公共方法findCreated()和findRegistered()变得非常简洁，清晰地表达了它们的目的——调用通用查找方法并提供特定的过滤条件。
• 更好的扩展性： 如果未来需要添加findDeleted()或findArchived()等方法，只需添加一行代码调用find方法并传入新的Predicate即可，无需复制整个流处理链。

注意事项与最佳实践

1. 适用场景： 这种模式最适用于方法间差异集中在单一、可抽象的逻辑点（如条件判断、转换函数）时。如果差异点过多或过于复杂，可能需要考虑其他设计模式（如策略模式）。
2. 其他函数式接口： 除了Predicate，Java 8还提供了Function<T, R>（用于转换）、Consumer<T>（用于消费）、Supplier<T>（用于提供）等多种函数式接口，可以根据具体的差异类型选择合适的接口进行抽象。
3. 方法引用与Lambda表达式： 在本例中，B::isCreated是方法引用，它比b -> b.isCreated()更简洁。当Lambda表达式仅调用一个现有方法时，优先考虑使用方法引用。
4. 可见性： 通用方法通常应声明为private，以封装内部实现细节，并通过公共方法提供受控的访问接口。

总结

利用java.util.function.Predicate等函数式接口是Java 8及更高版本中避免代码重复、编写更简洁和更具表达力代码的强大手段。通过识别方法间的共同模式和差异点，并运用函数式接口将差异点抽象化，我们可以有效地重构代码，使其更加健壮、易于维护和扩展。这不仅是提高代码质量的有效途径，也是现代Java开发中不可或缺的实践。

以上就是Java代码重构：利用Predicate消除方法中单行差异的重复代码的详细内容，更多请关注php中文网其它相关文章！