我们如何使用 Java 函数实现 add(4)(10)(20)(3)(1).total ？

Question

我正在学习

的用法

java.util.function.Function

我写了一个代码，它使用 java 函数将 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);
    }

}

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

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

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 会添加那么多数字。

Answer 1

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

换句话说：这里的 "real" 功能解决方案不是用多个参数调用一个方法。您宁愿在某个列表中拥有值，然后通过在元素上应用函数来定义 "accumulates" 覆盖该列表内容的函数。

有关示例，请参阅 here。

Answer 2

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

这是 Java脚本中函数的一个很好的副作用，它是第一个 class 公民。这是一种将函数与封闭范围内的数据相关联的方法，然后能够在不丢失内部上下文的情况下传递这种关联。 common/simple 最常用的是缓存（它的正式名称是 memoisation）。

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

Answer 3

一个尽可能接近您的Java脚本代码的例子是

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

允许保留生成器并传递它。

我们如何使用 Java 函数实现 add(4)(10)(20)(3)(1).total ？

How we I achieve add(4)(10)(20)(3)(1).total using Java Function?

java

functional-programming

functional-java

java-8