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

Um einen Lambda-Ausdruck als Argument zu übergeben, muss der Typ des Parameters (der den Lambda-Ausdruck als Argument erhält) vom Typ der funktionalen Schnittstelle sein.

Wenn es eine funktionale Schnittstelle gibt -

interface IMyFunc {
   boolean test(int num);
}

Und es gibt eine Filtermethode, die den Wert int nur dann in die Liste aufnimmt, wenn er größer als 5 ist. Beachten Sie hier, dass die Filtermethode die Funktionsschnittstelle IMyFunc als einen der Parameter hat. In diesem Fall kann ein Lambda-Ausdruck als Argument für den Methodenparameter übergeben werden.

public class LambdaDemo {
    public static List<Integer> filter(IMyFunc testNum, List<Integer> listItems) {
        List<Integer> result = new ArrayList<Integer>();
        for(Integer item: listItems) {
            if(testNum.test(item)) {
                result.add(item);
            }
        }
        return result;
    }
    public static void main(String[] args) {
        List<Integer> myList = new ArrayList<Integer>();
        myList.add(1);
        myList.add(4);
        myList.add(6);
        myList.add(7);
        // calling filter method with a lambda expression
        // as one of the param
        Collection<Integer> values = filter(n -> n > 5, myList);

        System.out.println("Filtered values " + values);
    }
}

Answer 2

Für alle, die nach diesem Thema googeln, wäre eine gute Methode die Verwendung von java.util.function.BiConsumer . ex:

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

Der Ausdruck würde lauten: 166

Answer 3

Sie können wie oben erwähnt funktionale Schnittstellen verwenden. Im Folgenden sind einige der Beispiele aufgeführt

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

Ich hoffe, es hilft

Answer 4

Lambda ist kein Objekt, sondern eine funktionale Schnittstelle. Man kann so viele Funktionale Schnittstellen wie möglich definieren, indem man die @FunktionaleSchnittstelle als Annotation verwendet

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

Der Output wird wie folgt aussehen

Output : 7

Das Grundkonzept eines Lambda-Ausdrucks besteht darin, eine eigene Logik mit bereits definierten Argumenten zu definieren. Im obigen Code können Sie also die Definition der Funktion do von addition auf eine beliebige andere Definition ändern, aber Ihre Argumente sind auf 2 begrenzt.

Answer 5

Um einen Lamda-Ausdruck als Parameter zu übergeben, benötigen wir einen Typ, in dem wir ihn speichern können. Genauso wie ein Integer-Wert, den wir im primitiven int oder Integer-Klasse. Java hat keinen separaten Typ für Lamda-Ausdrücke, sondern verwendet eine Schnittstelle als Typ für die Aufnahme des Arguments. Aber diese Schnittstelle sollte eine funktionale Schnittstelle .