时间戳

首页 > 解决方案 > Java 8 中的函数类级别参数

java - Java 8 中的函数类级别参数

问题描述

我想更加努力地使用 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 的适当功能解决方案是什么？

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

标签： javadesign-patternsjava-8functional-programming

解决方案

函数式编程的要点是函数必须被视为一个对象。

但是你知道，函数（方法）不是java中的对象。它与 javascript 不同。

所以，我们应该使用名为 Predicate 的接口。

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

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

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

推荐阅读