Lambda不是一个对象，而是一个功能接口。 使用@FuntionalInterface作为注释，可以定义尽可能多的功能接口

@FuntionalInterface
public interface SumLambdaExpression {
     public int do(int a, int b);
}

public class MyClass {
     public static void main(String [] args) {
          SumLambdaExpression s = (a,b)->a+b;
          lambdaArgFunction(s);
     }

     public static void lambdaArgFunction(SumLambdaExpression s) {
          System.out.println("Output : "+s.do(2,5));
     }
}

输出将如下所示

Output : 7

Lambda表达式的基本概念是定义自己的逻辑，但已经定义了参数。因此，在上面的代码中，您可以将do函数的定义从加法更改为任何其他定义，但参数限制为2。

Lambda不是一个对象，而是一个功能接口。 使用@FuntionalInterface作为注释，可以定义尽可能多的功能接口

@FuntionalInterface
public interface SumLambdaExpression {
     public int do(int a, int b);
}

public class MyClass {
     public static void main(String [] args) {
          SumLambdaExpression s = (a,b)->a+b;
          lambdaArgFunction(s);
     }

     public static void lambdaArgFunction(SumLambdaExpression s) {
          System.out.println("Output : "+s.do(2,5));
     }
}

输出将如下所示

Output : 7

Lambda表达式的基本概念是定义自己的逻辑，但已经定义了参数。因此，在上面的代码中，您可以将do函数的定义从加法更改为任何其他定义，但参数限制为2。

要使用Lambda表达式，您需要创建自己的函数接口，或者使用Java函数接口进行需要两个整数并作为值返回的操作。IntBinaryOperator

使用用户定义的功能接口

interface TwoArgInterface {

    public int operation(int a, int b);
}

public class MyClass {

    public static void main(String javalatte[]) {
        // this is lambda expression
        TwoArgInterface plusOperation = (a, b) -> a + b;
        System.out.println("Sum of 10,34 : " + plusOperation.operation(10, 34));

    }
}

使用Java函数接口

import java.util.function.IntBinaryOperator;

public class MyClass1 {

    static void main(String javalatte[]) {
        // this is lambda expression
        IntBinaryOperator plusOperation = (a, b) -> a + b;
        System.out.println("Sum of 10,34 : " + plusOperation.applyAsInt(10, 34));

    }
}

对于任何在谷歌上搜索这个的人来说，一个好方法是使用java.util.function. bicconsumer。 例:

Import java.util.function.Consumer
public Class Main {
    public static void runLambda(BiConsumer<Integer, Integer> lambda) {
        lambda.accept(102, 54)
    }

    public static void main(String[] args) {
        runLambda((int1, int2) -> System.out.println(int1 + " + " + int2 + " = " + (int1 + int2)));
    }

打印结果将是:166

这很简单。lambda表达式的目的是实现函数接口。它是只有一个方法的接口。这里有一篇关于预定义和遗留功能接口的很棒的文章。

不管怎样，如果你想实现你自己的功能接口，那就做吧。举个简单的例子:

public interface MyFunctionalInterface {
    String makeIt(String s);
}

所以让我们创建一个类，在这里我们将创建一个方法，它接受MyFunctionalInterface的类型:

public class Main {

    static void printIt(String s, MyFunctionalInterface f) {
        System.out.println(f.makeIt(s));
    }

    public static void main(String[] args) {

    }
}

你应该做的最后一件事是将MyFunctionalInterface的实现传递给我们已经定义的方法:

public class Main {

    static void printIt(String s, MyFunctionalInterface f) {
        System.out.println(f.makeIt(s));
    }

    public static void main(String[] args) {
        printIt("Java", s -> s + " is Awesome");
    }
}

就是这样!

对我来说，最有意义的解决方案是定义一个Callback接口:

interface Callback {
    void call();
}

然后在你想调用的函数中使用它作为参数:

void somewhereInYourCode() {
    method(() -> {
        // You've passed a lambda!
        // method() is done, do whatever you want here.
    });
}

void method(Callback callback) {
    // Do what you have to do
    // ...

    // Don't forget to notify the caller once you're done
    callback.call();
}

只是为了精确起见

lambda不是一个特殊的接口、类或任何你可以自己声明的东西。Lambda只是()->{}特殊语法的名称，它允许在作为参数传递单方法接口时具有更好的可读性。它的设计是为了取代这个:

method(new Callback() {
    @Override
    public void call() {
        // Classic interface implementation, lot of useless boilerplate code.
        // method() is done, do whatever you want here.
    }
});

所以在上面的例子中，Callback不是一个lambda，它只是一个常规接口;Lambda是可用于实现它的快捷语法的名称。