Lambda 在函数接口声明中，如何传递另一个函数接口作为参数？

我想做这样的事情-

final Function<Function<Integer, Integer>, Integer> function = (//appropriate syntax)

final Function=（//适当的语法）

---

有可能吗？如果是，正确的语法是什么？

当然，这是完全可能的，下面是一个如何实现它的示例

int input = 2;
Function<Integer, Integer> times10Function = i -> i * 10;
Function<Function<Integer, Integer>, Integer> minus10Function = func -> func.apply(input) - 10;

Integer result = minus10Function.apply(times10Function);
System.out.println(result); // 10

int输入=2；
功能时间10功能=i->i*10；
函数minus10Function=func->func.apply（输入）-10；
整数结果=minus10Function.apply（times10Function）；
System.out.println（结果）；//10

---

您不能执行

（i->i+10）->…

的事实与您不能在方法签名中使用常量的原因相同，这些是占位符，而不是实际的实现，因此它们由调用方引导。当然，这是完全可能的，下面是一个如何实现它的示例

int input = 2;
Function<Integer, Integer> times10Function = i -> i * 10;
Function<Function<Integer, Integer>, Integer> minus10Function = func -> func.apply(input) - 10;

Integer result = minus10Function.apply(times10Function);
System.out.println(result); // 10

int输入=2；
功能时间10功能=i->i*10；
函数minus10Function=func->func.apply（输入）-10；
整数结果=minus10Function.apply（times10Function）；
System.out.println（结果）；//10

---

事实上你不能做

（i->i+10）->…

，这与你不能在方法签名中使用常量的原因是一样的，这些是占位符，不是实际的实现，因此它们是由调用者引导的。然而，我想出了一个更好的例子，以便更清楚地理解-

        final int base1 = 3;
        final int base2 = 5;
        final int index = 2;

        final Function<BiFunction<Integer, Integer, Integer >, Function<Integer, Integer>> power = func ->
                myIndex -> {
            int result = 1;
            int base = func.apply(base1, base2);
            for (int i = 1; i <= myIndex; i++) {
                result *= base;
            }
            return result;
        };

        final BiFunction<Integer, Integer, Integer> addition = (num1, num2) -> num1 + num2;

        final int result = power.apply(addition).apply(index);

        System.out.println("Result: " + result);

这里有两个函数

加法

函数的任务是定义两个数字的加法

---

power

函数以

addition

函数作为参数，执行

base1

和

base2

的加法以获得

base

。作为第二个参数，

power

获取

索引，然后对power索引执行base的幂运算并返回结果。
Yassin Hajaj给出的答案是完美的。然而，我想出了一个更好的例子，以便更清楚地理解-

        final int base1 = 3;
        final int base2 = 5;
        final int index = 2;

        final Function<BiFunction<Integer, Integer, Integer >, Function<Integer, Integer>> power = func ->
                myIndex -> {
            int result = 1;
            int base = func.apply(base1, base2);
            for (int i = 1; i <= myIndex; i++) {
                result *= base;
            }
            return result;
        };

        final BiFunction<Integer, Integer, Integer> addition = (num1, num2) -> num1 + num2;

        final int result = power.apply(addition).apply(index);

        System.out.println("Result: " + result);

这里有两个函数

加法
函数的任务是定义两个数字的加法

power
函数以
addition
函数作为参数，执行
base1
和
base2
的加法以获得
base
。作为第二个参数，
power
获取
索引
，然后对power索引执行base的幂运算并返回结果。
是否正常？是否存在问题？我似乎无法理解
//适当的语法部分，例如，我在IDE
x->1
中遇到了错误。您仍然需要获取一个参数并返回一个。或者，如果您想调用传入的函数并提供
1
作为参数
x->x.apply（1）
。例如，在
function-function1=num->num+1
中可以完成，但如果我尝试
function-function2=（num->num+1）->num+2
则无法完成，请参见。您不需要在接受另一个函数的函数中定义
num->num+1
。您将把它作为一个参数传入，因此您将调用
函数。apply（num->num+1）
似乎可以吗？是否存在问题？我似乎无法理解
//适当的语法部分，例如，我在IDE
x->1
中遇到了错误。您仍然需要获取一个参数并返回一个。或者，如果您想调用传入的函数并提供
1
作为参数
x->x.apply（1）
。例如，在
function-function1=num->num+1
中可以完成，但如果我尝试
function-function2=（num->num+1）->num+2
则无法完成，请参见。您不需要在接受另一个函数的函数中定义
num->num+1
。您将把它作为参数传入，因此您将调用
函数。apply（num->num+1）
“您不能在方法签名中使用常量，这些是占位符，不是实际的实现，因此它们由调用者引导”-请explain@VLAZ请解释上述报价part@PayelSenapati简言之，不要试图将lambda放在需要参数的位置。e、 g.
x->x+1
是一个lambda函数，参数为
x
。尝试在其位置执行
y->y+2
是不正确的。@VLAZ将
func.apply（input）-10
中的
input
替换为2似乎工作得很好。并且没有装箱开销的变体：
IntUnaryOperator times10Function=i->i*10；ToIntFunction minus10Function=func->func.applyAsInt（2）-10；int result=minus10Function.applyAsInt（times10Function）“您不能在方法签名中使用常量，这些是占位符，不是实际的实现，因此它们由调用方引导”-请explain@VLAZ请解释上述报价part@PayelSenapati简单地说，不要试图将lambda放在预期参数的位置。e、 g.
x->x+1
是一个lambda函数，参数为
x
。尝试在其位置执行
y->y+2
是不正确的。@VLAZ将
func.apply（input）-10
中的
input
替换为2似乎工作得很好。并且没有装箱开销的变体：
IntUnaryOperator times10Function=i->i*10；ToIntFunction minus10Function=func->func.applyAsInt（2）-10；int result=minus10Function.applyAsInt（times10Function）