在Java 8中,方法可以创建为Lambda表达式,并且可以通过引用传递(在底层做一些工作)。网上有很多创建lambdas并将其与方法一起使用的示例,但没有示例说明如何创建以lambda作为参数的方法。它的语法是什么?
MyClass.method((a, b) -> a+b);
class MyClass{
//How do I define this method?
static int method(Lambda l){
return l(5, 10);
}
}
在Java 8中,方法可以创建为Lambda表达式,并且可以通过引用传递(在底层做一些工作)。网上有很多创建lambdas并将其与方法一起使用的示例,但没有示例说明如何创建以lambda作为参数的方法。它的语法是什么?
MyClass.method((a, b) -> a+b);
class MyClass{
//How do I define this method?
static int method(Lambda l){
return l(5, 10);
}
}
当前回答
要使用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));
}
}
其他回答
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);
}
使用您自己的接口的好处是您可以使用更清楚地表明意图的名称。
做以下…
你已经声明了方法(l) 您所要做的就是创建一个名为lambda的Interface,并声明一个抽象方法
public int add(int a,int b);
方法名称在这里不重要。
所以当你调用MyClass时。方法((a, b) - > a + b) 这个实现(a,b)->a+b将被注入到你的接口add方法中,所以当你调用l.add时,它将接受这个实现并执行a和b的加法并返回l.add(2,3)将返回5。 -基本上这就是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作为参数具有灵活性。它支持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的变量
这很简单。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");
}
}
就是这样!