java - Java 8 中的功能类级别参数

Question

我想更加努力地使用 Java 8 的函数式特性，并将我的想法转向该范式；但是，我不太确定如何协调这种情况。

例如我最近写了类似这样的东西:

public class ExampleClass {

    private ExampleData exampleData;
    private Function<ExampleData, Boolean> workFunction;

    public ExampleData getExampeData() {
        return exampleData;
    }

    public void setExampleData(ExampleData exampleData) {
        this.exampleData = exampleData;
    }

    public Function<ExampleData, Boolean> getWorkFunction() {
        return workFunction;
    }

    public void setWorkFunction(Function<ExampleData, Boolean> workFunction) {
        this.workFunction = workFunction;
    }
}

然后我继续像这样使用它......

public class Worker implements Callable {

    private final ExampleClass exampleClass;

    // ExampleClass serves as a container for the function and it's
    // input data in order to minimize the number of arguments
    // passed to this constructor. Otherwise would be
    // public Worker(ExampleData exampleData, Function<T, R> workFunction, ...) {
    // Note: using "..." here to represent more args.
    public Worker(ExampleClass exampleClass, ...) {
        this.exampleClass = exampleClass;
        ...
    }

    @Override
    public void call() {
        final Boolean isComplete = exampleClass.getWorkFunction().apply(exampleClass.getExampleData());
        if (isComplete) {
            ...
        }
        ...
    }
}

与我认为的更传统的方法相比，类似上述的方法是否更受欢迎？

public class ExampleClass {

    private ExampleData exampleData;

    public ExampleClass(ExampleData exampleData) {
        this.exampleData = exampleData;
    }

    public Boolean work() {
          return isComplete(exampleData);
    }
}

和实现类...

public class Worker implements Callable {

    private ExampleClass exampleClass;

    public Worker(ExampleClass exampleClass, ...) {
        this.exampleClass = exampleClass;
        ...
    }

    @Override
    public void call() {
        final Boolean isComplete = exampleClass.work();
        if (isComplete) {
            ...
        }
        ...
    }
}

如果我完全错了，什么是使用 Java 8 的合适的功能解决方案？

更新:假设我的示例不返回 boolean 值。在使用 Java 8 进行函数式编程的上下文中，是将函数显式传递为类级参数更好，还是只使用传统的面向对象的方式传递另一个执行该函数的类更好？

Answer 1

函数式编程的重点是必须将函数视为对象。

但是你知道，函数(方法)在java中不是对象。它与 javascript 不同。

因此，我们应该使用称为 Predicate 的接口(interface)。

List<Apple> apples = new ArrayList<>();

你想得到有重量的苹果。本来，

List<Apple> weightApples = new ArrayList<>();
for(int i = 0; 9< apples.size(); i++){
    if(apples.getWeight() > 10){
        weightApples.add(apples.get(i));
    }
}

这段代码。

在函数式编程中，函数是“纯函数”。

在纯函数中，应避免在函数中使用外部变量。

而且，我们不关心“使用函数的行”中的函数逻辑

首先，我们需要谓词接口(interface)。

interface Predicate<T>{
    public boolean pass(T t);
}

通过泛型，我们可以扩展对象类型。

我们可以制作过滤器。

public static <T> List<T> filter(List<T> list, Predicate<T> predicate){
    List<T> result = new ArrayList<>();
    for(T el : list){
        if(predicate.pass(el)){
            result.add(el);
        }
    }

    return result;
}

pass() 尚未实现。

可以通过匿名类实现。

最后，通过使用lamda，方法像对象一样被对待!

filter(apples, (Apple apple) -> apple.getWeight()>10);

我不是说英语的人，所以英语很差。

但我希望它对你有帮助!谢谢。