我们如何使用Java函数实现add（4）（10）（20）（3）（1）总计？

我正在学习使用

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

}

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

如何实现我在javaScript中所做的事情，如下所示

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

}

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将添加这些数字。

在java中不能完全这样做，您需要的是一个值流

换句话说，“真正”的函数解决方案不是用多个参数调用一个方法。而是将值放在某个列表中，然后通过在元素上应用函数来定义在该列表内容上“累积”的函数

---

请参阅以获取一些示例。

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

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

---

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

一个尽可能接近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();

可用作

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是一种类型化语言。为了能够访问字段，您需要定义一个类型，该类型实现

函数

，但允许您访问该接口契约以外的内容。此外，您似乎在Javascript代码中使用了相当于

函数的
，而不是
Function
。这与RxJava有什么关系？