So starten Sie die Arbeit mit Lambda Expressions in Java

Bevor die Unterstützung für Lambda-Ausdrücke durch JDK 8 hinzugefügt wurde, habe ich nur Beispiele in Sprachen wie C # und C ++ verwendet.

Nachdem diese Funktion zu Java hinzugefügt wurde, habe ich sie mir etwas genauer angesehen.

Durch das Hinzufügen von Lambda-Ausdrücken werden Syntaxelemente hinzugefügt, die die Ausdruckskraft von Java erhöhen. In diesem Artikel möchte ich mich auf grundlegende Konzepte konzentrieren, mit denen Sie sich vertraut machen müssen, damit Sie Ihrem Code heute Lambda-Ausdrücke hinzufügen können.

Schnelle Einführung

Lambda-Ausdrücke nutzen die parallelen Prozessfunktionen von Multi-Core-Umgebungen, wie dies bei der Unterstützung von Pipeline-Operationen für Daten in der Stream-API der Fall ist.

Dies sind anonyme Methoden (Methoden ohne Namen), mit denen eine von einer Funktionsschnittstelle definierte Methode implementiert wird. Es ist wichtig zu wissen, was eine funktionale Schnittstelle ist, bevor Sie sich mit Lambda-Ausdrücken die Hände schmutzig machen.

Funktionsschnittstelle

Eine funktionale Schnittstelle ist eine Schnittstelle, die nur eine abstrakte Methode enthält.

Wenn Sie sich die Definition der ausführbaren Java-Standardschnittstelle ansehen, werden Sie feststellen, wie sie in die Definition der funktionalen Schnittstelle fällt, da sie nur eine Methode definiert : run().

Im folgenden Codebeispiel ist die Methode computeNameimplizit abstrakt und die einzige definierte Methode, die MyName zu einer funktionalen Schnittstelle macht.

interface MyName{ String computeName(String str); }

Der Pfeiloperator

Lambda-Ausdrücke führen den neuen Pfeiloperator ->in Java ein. Es teilt die Lambda-Ausdrücke in zwei Teile:

(n) -> n*n

Die linke Seite gibt die für den Ausdruck erforderlichen Parameter an, die auch leer sein können, wenn keine Parameter erforderlich sind.

Die rechte Seite ist der Lambda-Körper, der die Aktionen des Lambda-Ausdrucks angibt. Es kann hilfreich sein, sich diesen Operator als "wird" vorzustellen. Zum Beispiel wird "n wird zu n * n" oder "n wird zu n im Quadrat".

Unter Berücksichtigung der Konzepte der Funktionsschnittstelle und des Pfeiloperators können Sie einen einfachen Lambda-Ausdruck zusammenstellen:

interface NumericTest { boolean computeTest(int n); } public static void main(String args[]) { NumericTest isEven = (n) -> (n % 2) == 0; NumericTest isNegative = (n) -> (n < 0); // Output: false System.out.println(isEven.computeTest(5)); // Output: true System.out.println(isNegative.computeTest(-5)); }
interface MyGreeting { String processName(String str); } public static void main(String args[]) { MyGreeting morningGreeting = (str) -> "Good Morning " + str + "!"; MyGreeting eveningGreeting = (str) -> "Good Evening " + str + "!"; // Output: Good Morning Luis! System.out.println(morningGreeting.processName("Luis")); // Output: Good Evening Jessica! System.out.println(eveningGreeting.processName("Jessica")); }

Die Variablen morningGreetingund eveningGreeting, Zeilen 6 und 7 im obigen Beispiel, verweisen auf die MyGreetingSchnittstelle und definieren verschiedene Begrüßungsausdrücke.

Beim Schreiben eines Lambda-Ausdrucks kann der Typ des Parameters im Ausdruck auch explizit wie folgt angegeben werden:

MyGreeting morningGreeting = (String str) -> "Good Morning " + str + "!"; MyGreeting eveningGreeting = (String str) -> "Good Evening " + str + "!";

Blockieren Sie Lambda-Ausdrücke

Bisher habe ich Proben von Lambdas mit einem Ausdruck behandelt. Es gibt einen anderen Ausdruckstyp, der verwendet wird, wenn der Code auf der rechten Seite des Pfeiloperators mehr als eine Anweisung enthält, die als Block-Lambdas bezeichnet wird :

interface MyString { String myStringFunction(String str); } public static void main (String args[]) { // Block lambda to reverse string MyString reverseStr = (str) -> { String result = ""; for(int i = str.length()-1; i >= 0; i--) result += str.charAt(i); return result; }; // Output: omeD adbmaL System.out.println(reverseStr.myStringFunction("Lambda Demo")); }

Generische funktionale Schnittstellen

Ein Lambda-Ausdruck kann nicht generisch sein. Aber die funktionale Schnittstelle, die einem Lambda-Ausdruck zugeordnet ist, kann. Es ist möglich, eine generische Schnittstelle zu schreiben und verschiedene Rückgabetypen wie folgt zu behandeln:

interface MyGeneric { T compute(T t); } public static void main(String args[]){ // String version of MyGenericInteface MyGeneric reverse = (str) -> { String result = ""; for(int i = str.length()-1; i >= 0; i--) result += str.charAt(i); return result; }; // Integer version of MyGeneric MyGeneric factorial = (Integer n) -> { int result = 1; for(int i=1; i <= n; i++) result = i * result; return result; }; // Output: omeD adbmaL System.out.println(reverse.compute("Lambda Demo")); // Output: 120 System.out.println(factorial.compute(5)); }

Lambda-Ausdrücke als Argumente

Eine häufige Verwendung von Lambdas besteht darin, sie als Argumente zu übergeben.

Sie können in jedem Code verwendet werden, der einen Zieltyp bereitstellt. Ich finde das aufregend, da ich damit ausführbaren Code als Argumente an Methoden übergeben kann.

Um Lambda-Ausdrücke als Parameter zu übergeben, stellen Sie einfach sicher, dass der Typ der funktionalen Schnittstelle mit dem erforderlichen Parameter kompatibel ist.

interface MyString { String myStringFunction(String str); } public static String reverseStr(MyString reverse, String str){ return reverse.myStringFunction(str); } public static void main (String args[]) { // Block lambda to reverse string MyString reverse = (str) -> { String result = ""; for(int i = str.length()-1; i >= 0; i--) result += str.charAt(i); return result; }; // Output: omeD adbmaL System.out.println(reverseStr(reverse, "Lambda Demo")); }

Diese Konzepte bieten Ihnen eine gute Grundlage für die Arbeit mit Lambda-Ausdrücken. Schauen Sie sich Ihren Code an und sehen Sie, wo Sie die Ausdruckskraft von Java steigern können.