对于任何在谷歌上搜索这个的人来说，一个好方法是使用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

对于不超过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已经提供的所有接口，请参阅此页。

您可以使用如上所述的功能接口。 下面是一些例子

Function<Integer, Integer> f1 = num->(num*2+1);
System.out.println(f1.apply(10));

Predicate<Integer> f2= num->(num > 10);
System.out.println(f2.test(10));
System.out.println(f2.test(11));

Supplier<Integer> f3= ()-> 100;
System.out.println(f3.get());

希望能有所帮助

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

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

使用lambda作为参数具有灵活性。它支持java中的函数式编程。基本语法是

Param -> method_body

下面是一种方法，您可以定义一个方法，将函数接口(使用lambda)作为参数。 a.如果你想在函数接口中定义一个方法， 例如，函数接口作为参数/参数提供给从main()调用的方法

@FunctionalInterface
interface FInterface{
    int callMeLambda(String temp);
}


class ConcreteClass{
        
    void funcUsesAnonymousOrLambda(FInterface fi){
        System.out.println("===Executing method arg instantiated with Lambda==="));
    }
        
    public static void main(){
        // calls a method having FInterface as an argument.
        funcUsesAnonymousOrLambda(new FInterface() {
        
            int callMeLambda(String temp){ //define callMeLambda(){} here..
                return 0;
            }
        }
    }
        
/***********Can be replaced by Lambda below*********/
        funcUsesAnonymousOrLambda( (x) -> {
            return 0; //(1)
        }
       
    }

FInterface fi = (x) ->{返回0;}; funcUsesAnonymousOrLambda (fi); 在上面我们可以看到，lambda表达式是如何被接口替换的。

以上解释了lambda表达式的一个特殊用法，还有更多。 裁判 Java 8 lambda内部的lambda不能修改外部lambda的变量

如果你同时使用Java和Kotlin语言(就像我们在Android开发中所做的那样)，你可以传递lambda函数而不定义任何额外的接口:

import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.functions.Function2;

void foo(Function0<Boolean> param1) //for zero param
{
    param1.invoke();
}

void foo1(Function1<Integer, Boolean> param1) //for one param
{
    param1.invoke(1);
}

void foo2(Function2<Integer, Boolean, Boolean> param1) //for two param
{
    param1.invoke(1, true);
}

//how to call
void main() 
{
    foo(() -> {
        return true;
    });

    foo1((var1) -> {
        return true;
    });

    foo2((var1, var2) -> {
        return true;
    });
        
}