在Java8中，带2个箭头的lambda是什么意思？

我以前读过一些Java8教程

现在我遇到了以下话题：

在这里，我看到以下代码：

IntFunction<IntUnaryOperator> curriedAdd = a -> b -> a + b;
System.out.println(curriedAdd.apply(1).applyAsInt(12));

根据表达式的左侧，此行应实现以下功能：

R apply(int value); 

---

在此之前，我只遇到了一个箭头lambdas。

如果您将其表示为非简写lambda语法或前lambda Java匿名类语法，则更清楚发生了什么

原来的问题。为什么有两支箭？很简单，有两个函数正在定义。。。第一个函数是定义函数的函数，第二个函数是该函数的结果，它恰好也是函数。每个都需要一个

->

操作符来定义它

非速记

IntFunction curriedAdd=（a）->{
返回（b）->{
返回a+b；
};
};

Java 8之前的Lambda

IntFunction curriedAdd=新的IntFunction（）{
@凌驾
公共IntUnaryOperator应用（最终整数值）{
IntUnaryOperator op=新的IntUnaryOperator（）{
@凌驾
公共整数applyAsInt（整数操作数）{
返回操作数+值；
}
};
返回op；
}
};
一个
int函数
是一个
int->R
函数。
IntUnaryOperator
是一种功能
int->int

a -> b -> a + b;
^    |         |
|     ---------
|         ^
|         |
|         The IntUnaryOperator (that takes an int, b) and return an int (the sum of a and b)
|
The parameter you give to the IntFunction

因此，
int函数
是以
int
为参数并返回以
int
为参数并返回
int
的函数

a -> b -> a + b;
^    |         |
|     ---------
|         ^
|         |
|         The IntUnaryOperator (that takes an int, b) and return an int (the sum of a and b)
|
The parameter you give to the IntFunction

如果您使用匿名类来“分解”lambda，可能会更清楚：

IntFunction<IntUnaryOperator> add = new IntFunction<IntUnaryOperator>() {
    @Override
    public IntUnaryOperator apply(int a) {
        return new IntUnaryOperator() {
            @Override
            public int applyAsInt(int b) {
                return a + b;
            }
        };
    }
};

IntFunction add=new IntFunction（）{
@凌驾
公共肠套叠手术器应用（INTA）{
返回新的IntUnaryOperator（）{
@凌驾
公共int applyAsInt（int b）{
返回a+b；
}
};
}
};
让我们用括号重写lambda表达式，使其更清楚：

IntFunction<IntUnaryOperator> curriedAdd = a -> (b -> (a + b));

IntFunction<IntUnaryOperator> curriedAdd = a -> (b -> (a + b));

IntFunction curriedAdd=a->（b->（a+b））；

因此，我们声明了一个函数，它接受一个
int
，返回一个
函数
。更具体地说，返回的函数接受一个
int
并返回一个
int
（两个元素的总和）：这可以表示为一个

因此，
curriedAdd
是一个函数，它接受一个
int
并返回一个
IntUnaryOperator
，因此它可以表示为。
添加括号可以更清楚地说明这一点：

IntFunction<IntUnaryOperator> curriedAdd = a -> (b -> (a + b));

IntFunction<IntUnaryOperator> curriedAdd = a -> (b -> (a + b));

IntFunction curriedAdd=a->（b->（a+b））；

或者，中间变量可能会有所帮助：

IntFunction<IntUnaryOperator> curriedAdd = a -> {
    IntUnaryOperator op = b -> a + b;
    return op;
};

IntFunction curriedAdd=a->{
气管插管术者op=b->a+b；
返回op；
};
如果您仔细看，它可能会变得更清晰：
IntFunction
是一个
功能接口。它表示接受
int
并返回
R
类型值的函数

在这种情况下，返回类型
R
也是
功能接口
，即
IntUnaryOperator
。因此，第一个（外部）函数本身返回一个函数

在这种情况下：当应用于
int
时，
curriedAdd
应返回一个函数，该函数再次接受
int
（并再次返回
int
，因为
IntUnaryOperator
就是这样做的）

在函数式编程中，通常将函数类型写为
param->return\u value
，您可以在这里看到这一点。所以
curriedAdd
的类型是
int->int->int
（或者
int->（int->int）
，如果您更喜欢的话）

Java8的lambda语法与此一致。要定义这样一个函数，您需要编写

a -> b -> a + b

这与实际的lambda演算非常相似：

λa λb a + b

λb a+b
是一个函数，它接受单个参数
b
并返回一个值（总和）
λaλb a+b
是一个函数，它接受单个参数
a
，并返回单个参数的另一个函数
λaλb a+b
返回
λb a+b
并将
a
设置为参数值。
这是两个lambda表达式

IntFunction<IntUnaryOperator> curriedAdd = 
  a -> { //this is for the fixed value
    return b -> { //this is for the add operation
      return a + b;
    };
  }

IntUnaryOperator addTwo = curriedAdd.apply(2);
System.out.println(addTwo.applyAsInt(12)); //prints 14

IntFunction curriedAdd=
a->{//这是固定值
返回b->{//这是用于添加操作的
返回a+b；
};
}
IntUnaryOperator addTwo=当前数据应用（2）；
System.out.println（addTwo.applyAsInt（12））//印刷品14
你明白咖喱的意思吗？这对于这个问题来说是非常重要的。它只是一个lambda，返回一个lambda。预lambda需要一个
final int值
是的，你是对的，但我仍然使用Java 8编译器，允许你使用“有效的final”@gstackoverflow是的，但是Java8不是
pre-lambda
，您也可以在Java8中使用pre-lambda样式。我写的JFYLAMBDAS不是为了让人们得分吗？：-）