Lambdas纯粹是一个调用站点构造:lambda的接收方不需要知道涉及到lambda，而是接受具有适当方法的Interface。

换句话说，您定义或使用一个函数接口(即具有单一方法的接口)，该接口接受并返回您想要的内容。

自Java 8以来，Java .util.function中有一组常用的接口类型。

对于这个特定的用例，有java.util.function.IntBinaryOperator和一个int applyAsInt(int left, int right)方法，所以你可以这样写你的方法:

static int method(IntBinaryOperator op){
    return op.applyAsInt(5, 10);
}

但你也可以定义自己的接口，并像这样使用它:

public interface TwoArgIntOperator {
    public int op(int a, int b);
}

//elsewhere:
static int method(TwoArgIntOperator operator) {
    return operator.op(5, 10);
}

然后调用以lambda作为参数的方法:

public static void main(String[] args) {
    TwoArgIntOperator addTwoInts = (a, b) -> a + b;
    int result = method(addTwoInts);
    System.out.println("Result: " + result);
}

使用您自己的接口的好处是您可以使用更清楚地表明意图的名称。

对我来说，最有意义的解决方案是定义一个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是可用于实现它的快捷语法的名称。

对于不超过2个参数的函数，可以传递它们而无需定义自己的接口。例如,

class Klass {
  static List<String> foo(Integer a, String b) { ... }
}

class MyClass{

  static List<String> method(BiFunction<Integer, String, List<String>> fn){
    return fn.apply(5, "FooBar");
  }
}

List<String> lStr = MyClass.method((a, b) -> Klass.foo((Integer) a, (String) b));

在bifuncfunction <Integer, String, List<String>>中，Integer和String是其参数，List<String>是其返回类型。

对于只有一个形参的函数，可以使用function <T, R>，其中T是它的形参类型，R是它的返回值类型。有关Java已经提供的所有接口，请参阅此页。

基本上，要将lambda表达式作为参数传递，我们需要一个可以保存它的类型。就像我们在原始int或integer类中持有的整数值一样。Java没有单独的lambda表达式类型，而是使用接口作为类型来保存参数。但是这个接口应该是一个功能接口。

要使用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));

    }
}

有一个支持lambda的Java 8 JavaDocs的公共web可访问版本，链接到http://lambdafaq.org/lambda-resources。(这显然应该是对Joachim Sauer的回答的评论，但我无法进入我的SO帐户，我需要声望点来添加评论。)lambdafaq站点(由我维护)回答了这个问题和许多其他Java-lambda问题。

注意:这个答案是在Java 8 GA文档公开之前写的。不过，我把它留在了原处，因为Lambda FAQ对于学习Java 8中引入的特性的人来说可能仍然有用。