1

我正在学习使用，

java.util.function.Function

我写了一个代码，它使用 java Function 将 4 添加到自身，

代码如下，

public class Test01 {

    public static void main(String[] args) {
        Function<Integer,Integer> addFunction = new Function<Integer,Integer>() {
            private int total = 0; 
            public Integer apply(Integer value) {               
                this.total += value; 
                return this.total;
            }
        };



        int finalTotal = addFunction.andThen(addFunction)
                                    .andThen(addFunction)
                                    .andThen(addFunction)
                                    .apply(4);

        System.out.println(finalTotal);
    }

}

当我运行上面的代码时，我得到的输出是

32

我怎样才能实现我在 javaScript 中所做的事情，如下所示，

var fn19 = function(){

        var addNum = function(num){

            var fn = function(num2){
                fn.sum += num2;             
                return fn;
            };

            fn.sum = num;   
            return fn;
        };

        print("addNum(3)(4)(3)(10) ==>  "+addNum(3)(4)(3)(10).sum); 
};

fn19();

上面代码的输出是

addNum(3)(4)(3)(10) ==> 20

我可以有相同类型的 java 函数调用，我可以传递尽可能多的数字参数，并且 addFunction 将添加这些数字。

4

3 回答 3

1

一个尽可能接近您的 JavaScript 代码的示例是

class QuestionableConstruct {
    int sum;
    QuestionableConstruct add(int num2) {
        sum += num2;
        return this;
    }
}
Runnable fn19 = () -> {
    IntFunction<QuestionableConstruct> addNum = num -> {
        QuestionableConstruct fn = new QuestionableConstruct();
        fn.sum = num;   
        return fn;
    };
    System.out.println("addNum(3)(4)(3)(10)==> "+addNum.apply(3).add(4).add(3).add(10).sum);
};
fn19.run();

一个更像Java的解决方案是

interface Add {
    int sum();
    default Add add(int num) {
        int sum = sum() + num;
        return () -> sum;
    }
    static Add num(int num) {
        return () -> num;
    }
}

可用作

System.out.println("addNum(3)(4)(3)(10) ==>  "+Add.num(3).add(4).add(3).add(10).sum());

与 JavaScript 构造不同，它使用真正的不可变函数。考虑

Add a = Add.num(1).add(2).add(3);
System.out.println("1+2+3+4+5 = "+a.add(4).add(5).sum());
System.out.println("1+2+3+10+20 = "+a.add(10).add(20).sum());

它工作顺利，没有干扰。

但是，当然，如果您只想对可变数量的项目求和，请使用

System.out.println("addNum(3)(4)(3)(10) ==>  "+IntStream.of(3, 4, 3, 10).sum());

或者如果你想要一个可变的累加器，使用

System.out.println("addNum(3)(4)(3)(10) ==>  "+
    IntStream.builder().add(3).add(4).add(3).add(10).build().sum());

这允许保留构建器并传递它。

于 2019-04-08T07:51:31.800 回答
0

您不能在 Java 中完全做到这一点，您正在寻找的是减少值流。

换句话说：这里“真正的”功能解决方案不是调用具有多个参数的方法。您宁愿拥有某个列表中的值，然后通过对元素应用函数来定义在该列表的内容上“累积”的函数。

有关一些示例，请参见此处。

于 2019-04-07T15:15:47.157 回答
0

您在 JavaScript 世界中描述的技术正在利用闭包。

这是 JavaScript 中的函数作为一等公民的一个很好的副作用。这是一种将函数与封闭范围内的数据相关联的方法，然后能够在不丢失内部上下文的情况下传递这种关联。最常见/最简单的用途是缓存（它的正式名称是记忆）。

您需要 Java 中的函数（方法）是第一类，但这样做是多余的，因为设计类是关联数据和方法的实体，使得在这种情况下闭包的整个概念是多余的。

于 2019-04-07T15:37:40.470 回答