本文探讨了在java中如何通过利用函数式接口（如`predicate`）来消除因方法内部仅存在一行差异而导致的重复代码。通过将变化的逻辑抽象为可传递的行为参数，我们可以重构出简洁、可维护的公共方法，从而显著提升代码质量和可读性，遵循dry（don't repeat yourself）原则。
在软件开发中，代码重复（Code Duplication）是一个常见的问题，它不仅增加了代码库的体积，更重要的是降低了代码的可维护性、可读性，并增加了引入bug的风险。特别是在Java等面向对象语言中，当多个方法的核心逻辑相似，仅在某几行代码上存在微小差异时，开发者往往会不自觉地复制代码块，从而导致重复。本文将深入探讨如何利用Java 8及更高版本提供的函数式接口特性，优雅地解决这类问题。
引言：代码重复的挑战
考虑以下场景，一个A类包含一个B对象的列表，并提供了两个方法findCreated()和findRegistered()，用于根据B对象的不同状态进行过滤和处理。
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 + ")";
}
}从上述代码可以看出，findCreated()和findRegistered()方法的大部分逻辑是相同的，唯一的区别在于filter()操作中使用的条件：一个是b.isCreated()，另一个是b.isRegistered()。这种“一字之差”的重复代码，如果未来需要修改通用逻辑（例如，改变some filter operations或some mapping），将不得不在多个地方进行修改，极易遗漏并引入错误。
解决方案：利用函数式接口抽象行为
为了解决这种重复问题，我们可以将方法中变化的逻辑（即过滤条件）作为参数传递给一个公共的辅助方法。Java 8引入的函数式接口为实现这一目标提供了强大的支持。
立即学习“Java免费学习笔记（深入）”；
核心思想： 识别出重复代码中的变化点，将其封装为一个函数式接口的实例，然后将该实例作为参数传递给一个包含通用逻辑的私有（或受保护）方法。
Predicate
重构步骤：
- 识别变化点： 在本例中，变化点是filter()方法内部的Lambda表达式b -> b.isCreated()和b -> b.isRegistered()。
- 创建辅助方法： 定义一个私有方法，例如find(Predicate filter)，它将接收一个Predicate作为参数。
- 迁移通用逻辑： 将findCreated()和findRegistered()中重复的流操作逻辑（list.stream().some filter operations.some mapping.collect(...)）迁移到新的find()辅助方法中。
- 应用参数化过滤： 在辅助方法中，使用传入的Predicate参数来执行过滤操作，即stream.filter(filter)。
- 调用辅助方法： 修改原始的findCreated()和findRegistered()方法，使其调用新的find()辅助方法，并传入具体的过滤逻辑（使用Lambda表达式或方法引用）。
重构实践与示例代码
按照上述步骤，我们可以将A类重构如下：
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 + ")";
}
}
*/在上述重构后的代码中，find(Predicate filter)方法封装了所有通用的流操作逻辑。findCreated()和findRegistered()现在只需调用这个辅助方法，并分别传入B::isCreated和B::isRegistered作为Predicate的实现。这里的B::isCreated和B::isRegistered是方法引用，它们是Lambda表达式b -> b.isCreated()和b -> b.isRegistered()的简洁形式。
优势与注意事项
优势：
- 消除代码重复 (DRY原则)： 核心的流处理逻辑只存在于一个地方，避免了冗余。
- 提高可读性： findCreated()和findRegistered()方法的意图变得非常清晰——它们只是调用一个通用查找方法并传入特定的过滤条件。
- 增强可维护性： 如果需要修改通用逻辑（例如，改变流的映射或收集方式），只需修改find()方法一处即可，大大降低了维护成本和出错率。
- 更好的扩展性： 可以轻松添加新的查找方法（如findCreatedAndRegistered()），只需提供一个新的Predicate实现，而无需复制代码。
- 设计模式关联： 这种模式在一定程度上体现了策略模式（Strategy Pattern）的思想，其中Predicate接口充当了策略接口，而B::isCreated等则是具体的策略实现。它允许在运行时选择不同的算法或行为。
注意事项：
- 过度抽象： 这种方法最适用于差异点确实很小且能被标准函数式接口（如Predicate、Function、Consumer等）清晰表达的场景。如果方法间的差异过于复杂，或者需要多个不同类型的参数来表达差异，过度使用函数式接口可能会使代码变得难以理解。
- 性能考量： 尽管现代JVM对Lambda表达式和方法引用进行了高度优化，但在极度性能敏感的场景下，仍需谨慎。然而，在大多数业务应用中，这种抽象带来的性能开销可以忽略不计。
- 团队熟悉度： 对于不熟悉Java 8+函数式编程的团队成员，可能需要一定的学习曲线来适应这种代码风格。
总结
通过利用Java的函数式接口，我们可以有效地消除因方法内部微小差异导致的重复代码。将变化的逻辑抽象为可传递的行为参数，不仅遵循了DRY原则，还显著提升了代码的可读性、可维护性和扩展性。这种重构模式是现代Java开发中一项强大的技术，鼓励开发者在日常编码中积极应用，以构建更健壮、更易维护的应用程序。
