Wie definiere ich in Java 8 eine Methode, die ein Lambda als Parameter annimmt?

Question

In Java 8 können Methoden als Lambda-Ausdrücke erstellt und per Referenz übergeben werden (mit ein wenig Arbeit unter der Haube). Es gibt viele Beispiele im Internet, in denen Lambdas erstellt und mit Methoden verwendet werden, aber keine Beispiele dafür, wie man eine Methode erstellt, die ein Lambda als Parameter annimmt. Wie lautet die Syntax dafür?

MyClass.method((a, b) -> a+b);

class MyClass{
  //How do I define this method?
  static int method(Lambda l){
    return l(5, 10);
  }
}

Answer 1

Nun, das ist ganz einfach. Der Zweck eines Lambda-Ausdrucks ist die Implementierung einer funktionalen Schnittstelle. Es ist die Schnittstelle mit nur einer Methode. Hier ist ein hervorragender Artikel über vordefinierte und veraltete funktionale Schnittstellen.

Wie auch immer, wenn Sie Ihre eigene funktionale Schnittstelle implementieren wollen, machen Sie es. Nur als einfaches Beispiel:

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

Lassen Sie uns also eine Klasse erstellen, in der wir eine Methode erstellen, die den Typ von MyFunctionalInterface :

public class Main {

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

    public static void main(String[] args) {

    }
}

Das letzte, was Sie tun sollten, ist die Übergabe der Implementierung der MyFunctionalInterface zu der von uns definierten Methode:

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

Das war's!

Answer 2

Gehen Sie wie folgt vor

Sie haben erklärt method(lambda l) Alles was Sie tun wollen, ist eine Schnittstelle mit dem Namen lambda und deklarieren eine abstrakte Methode

public int add(int a,int b);  

Der Name der Methode spielt hier keine Rolle..

Wenn Sie also anrufen MyClass.method( (a,b)->a+b) Diese Umsetzung (a,b)->a+b wird in die Add-Methode der Schnittstelle injiziert, d.h. wenn Sie die l.add wird es diese Implementierung nehmen und die Hinzufügung von a y b et return l.add(2,3) wird zurückgegeben 5 . - Im Grunde ist es das, was Lambda tut

Answer 3

Hier ist ungefähr, wie C# dieses Problem behandelt (aber als Java-Code ausgedrückt). So etwas könnte fast alle Ihre Anforderungen erfüllen:

import static org.util.function.Functions.*;

public class Test {

    public static void main(String[] args)
    {
        Test.invoke((a, b) -> a + b);       
    }

    public static void invoke(Func2<Integer, Integer, Integer> func)
    {
        System.out.println(func.apply(5, 6));
    }
}

---

package org.util.function;

public interface Functions {

    //Actions:
    public interface Action {
        public void apply();
    }

    public interface Action1<T1> {
        public void apply(T1 arg1);
    }

    public interface Action2<T1, T2> {
        public void apply(T1 arg1, T2 arg2);
    }

    public interface Action3<T1, T2, T3> {
        public void apply(T1 arg1, T2 arg2, T3 arg3);
    }

    public interface Action4<T1, T2, T3, T4> {
        public void apply(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
    }

    public interface Action5<T1, T2, T3, T4, T5> {
        public void apply(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
    }

    public interface Action6<T1, T2, T3, T4, T5, T6> {
        public void apply(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
    }

    public interface Action7<T1, T2, T3, T4, T5, T6, T7> {
        public void apply(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
    }

    public interface Action8<T1, T2, T3, T4, T5, T6, T7, T8> {
        public void apply(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
    }

    //Functions:
    public interface Func<TResult> {
        public TResult apply();
    }

    public interface Func1<T1, TResult> {
        public TResult apply(T1 arg1);
    }

    public interface Func2<T1, T2, TResult> {
        public TResult apply(T1 arg1, T2 arg2);
    }

    public interface Func3<T1, T2, T3, TResult> {
        public TResult apply(T1 arg1, T2 arg2, T3 arg3);
    }

    public interface Func4<T1, T2, T3, T4, TResult> {
        public TResult apply(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
    }

    public interface Func5<T1, T2, T3, T4, T5, TResult> {
        public TResult apply(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
    }

    public interface Func6<T1, T2, T3, T4, T5, T6, TResult> {
        public TResult apply(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
    }

    public interface Func7<T1, T2, T3, T4, T5, T6, T7, TResult> {
        public TResult apply(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
    }

    public interface Func8<T1, T2, T3, T4, T5, T6, T7, T8, TResult> {
        public TResult apply(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
    }
}

Answer 4

Wenn Sie Java zusammen mit der Sprache Kotlin verwenden (wie wir es in der Android-Entwicklung tun), können Sie Lambda-Funktionen übergeben, ohne eine zusätzliche Schnittstelle zu definieren:

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

}

Answer 5

Die Verwendung von lambda als Parameter ist flexibel. Sie ermöglicht die funktionale Programmierung in Java. Die grundlegende Syntax lautet

param -> methode_body

Nachfolgend ein Weg, wie Sie eine Methode definieren können, die eine funktionale Schnittstelle (Lambda wird verwendet) als Parameter nimmt. a. wenn Sie eine Methode definieren wollen, die innerhalb einer funktionalen Schnittstelle deklariert ist, sagen wir, die funktionale Schnittstelle als Argument/Parameter für eine Methode angegeben wird, die von 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) -> { return 0; };

funcUsesAnonymousOrLambda(fi);

Hier oben ist zu sehen, wie ein Lambda-Ausdruck durch eine Schnittstelle ersetzt werden kann.

Oben wird eine bestimmte Verwendung des Lambda-Ausdrucks erklärt, es gibt noch weitere. ref Java 8 Lambda innerhalb eines Lambdas kann die Variable des äußeren Lambdas nicht ändern