Technischer Projektleiter
Java Lambda-Ausdrücke: Was sind sie und wie verwendet man sie?
Viele Java-Entwickler sind bereits mit Lambda-Ausdrücken konfrontiert worden. Diese Funktion wurde bereits in der Version 2014 von Java 8 hinzugefügt, ist also nicht neu. Sie wird häufig von Programmierern verwendet und bietet viele Vorteile. Wenn dir jedoch Lambda-Ausdrücke Schwierigkeiten bereiten oder du nicht weißt, was sie darstellen, bist du hier genau richtig.
Was ist ein Lambda-Ausdruck (expression)?
Ein Lambda-Ausdruck stellt eine Funktionalität dar, die in Java 8 hinzugefügt wurde. Es handelt sich um einen kurzen Codeblock, ähnlich einer Methode, der jedoch im Gegensatz zu einer Methode keinen Methodennamen benötigt und direkt im Methodenkörper implementiert werden kann.
Lambda hat mehrere Vorteile, wie z.B.:
- er vereinfacht den Code und bietet eine bessere Lesbarkeit – anstelle von mehrzeiligem Code müssen nur wenige Zeilen geschrieben werden,
- ermöglicht die Verwendung der funktionalen Programmierung – das bedeutet, dass eine Funktion als Eingabeparameter einer anderen Funktion verwendet werden kann,
- verbessert die Code-Parallelisierung – mit anderen Worten, eine effizientere Code-Ausführung auf Multi-Core-Prozessen.
Syntax des Lambda-Ausdrucks
Jeder Lambda-Ausdruck muss die richtige Syntax haben. Nur in diesem Fall wird es die gewünschte Wirkung haben. Lambda muss enthalten:
- Liste der Argumente,
- das Pfeilzeichen,
- den Körper des Ausdrucks.
In der Praxis kann das folgendermaßen aussehen:
> (Argumentliste) – Ausdruckskörper
> (Argumentliste) – { Ausdruck1; Ausdruck2, …}
Die Argumentliste kann auch leer sein, zum Beispiel:
> () – { System.out.println(„Hallo“); }
Der Körper des Ausdrucks muss nur dann geschweifte Klammern enthalten, wenn er mehr als eine Zeile Code enthält. Im obigen Beispiel können wir ihn weglassen:
> () – System.out.println(„Hallo“);
Die Argumenttypen können, aber müssen nicht definiert sein, was bedeutet, dass die beiden Ausdrücke gleichwertig sind:
> (x) – System.out.println(x);
> (Int x) – System.out.println(x);
Lambda kann auch Werte zurückgeben, ohne das Wort return zu verwenden. Der Compiler kann sie selbst ableiten:
> (x, y) – x + y
Beispiele für die Verwendung von lambda
Für eine bessere Vorstellung geben wir drei Beispiele, wie ein Lambda-Ausdruck verwendet werden kann.
Beispiel Nr. 1: Lambda-Ausdruck in forEach
Lambda-Ausdrücke werden oft als Funktionsparameter verwendet.
package com.test;
import java.util.ArrayList;
public class LambdaExample1 {
public static void main(String[] args) {
ArrayList<Integer> numbers = new ArrayList<Integer>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
// Vytlaci na konzolu 1 2 3 pod sebou.
numbers.forEach(x -> System.out.println(x));
}
}Der Lambda-Ausdruck kann in einer Variablen gespeichert werden. Es gilt jedoch nur, wenn die Variable ein Interface mit einer einzigen Methode ist. In solchen Fällen muss der Lambda-Ausdruck die gleiche Anzahl von Parametern und den gleichen Rückgabetyp haben wie die Methode.
Java hat viele Benutzeroberflächen. Ein Beispiel ist das Interface Consumer, das Listen verwendet:
java.util.function.Consumer<Integer> function = x -> System.out.println(x);
numbers.forEach(function);Beispiel Nr. 2: Definieren einer funktionalen Schnittstelle für einen Lambda-Ausdruck
Das zweite Beispiel zeigt die Erstellung einer funktionalen Schnittstelle für grundlegende mathematische Operationen. Man kann darin Ausdrücke für Addition, Subtraktion, Multiplikation, Division und die Methode operate einfügen. Seine Aufgabe ist es, zwei Zahlen zu nehmen und der zugehörige Lambda-Ausdruck berechnet ein Ergebnis, das wie folgt aussieht:
4 + 2 = 6
4 - 2 = 2
4 * 2 = 8
4 / 2 = 2Dank der Methode operate berechnet der zugehörige Lambda-Ausdruck schnell und einfach das Ergebnis.
Man kann Lambda-Ausdrücke in ein funktionales Interface für grundlegende mathematische Operationen einfügen.
package com.test;
import java.lang. ArithmeticException;
public class LambdaExample2 {
// Deklarovanie interfejsu pre lamda vyraz
interface MathOperation {
int operation(int x, int y);
}
// Deklarovanie metody pre matematicku operaciu
private int operate (int x, int y, MathOperation mathOperation) {
return mathOperation.operation (x, y);
}
// Vypis celej operacie do konzoly.
public static void printResult(int x, char c, int y, int z) {
System.out.printf("%d %s %d = %d\n", x, c, y, z);
}
public static void main(String[] args) {
// Bez deklaracie typu
MathOperation addition = (x, y) -> x + y;
// S deklaraciou typu (int)
MathOperation substraction = (int x, int y) -> x - y;
// S klucovym slovom return (musi byt v krutenych zatvorkach)
MathOperation multiplication = (x, y) -> { return (x * y); };
// Viacriadkovy lambda vyraz
MathOperation division = (x, y) -> {
if(y != 0)
return (x / y);
else
throw new ArithmeticException("You shouldn't divide a number by zero!");
};
LambdaExample2 test = new LambdaExample2();
int a = 4; int b = 2;
// Scitanie dvoch cisiel
printResult(a, '+', b, test.operate (a, b, addition));
// Odcitanie dvoch cisiel
printResult(a, '-', b, test.operate (a, b, substraction));
// Vynasobenie dvoch cisiel
printResult(a, '*', b, test.operate (a, b, multiplication));
// Vydelenie dvoch cisiel
printResult(a, '/', b, test.operate (a, b, division));
}
}Beispiel Nr. 3: Sortieren, Filtern und Iterieren von Sammlungen über Lambda-Ausdrücke
Ein Vorteil von Lambda-Ausdrücken ist, dass sie die Notwendigkeit verringern, eigene Hilfsmethoden zu schreiben. Gleichzeitig verkürzen und verdeutlichen sie den Code, was die ganze Arbeit erleichtert. Die Leistungsfähigkeit von Lambdas zeigt sich vor allem in Kombination mit anderen Java-Funktionen, wie z.B. Sammlungen.
Im folgenden Beispiel wird gezeigt, wie man Objekte in einer Sammlung mit Hilfe von Lambda-Ausdrücken einfach sortieren, filtern und iterieren kann:
package com.test;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
class Product {
String name;
double price;
public Product(String name, double price) {
this.name = name;
this.price = price;
}
}
public class LambdaExample3 {
public static Product createProduct(String name, double price) {
return new Product(name, price);
}
public static void main(String[] args) {
List<Product> products = new ArrayList();
products.add(createProduct("Chlieb", 1.0));
products.add(createProduct("Mlieko", 0.5));
products.add(createProduct("Keksy", 0.8));
products.add(createProduct("Smotana", 0.4));
products.add(createProduct ("Cokolada", 0.7));
// Sortovanie nazvov produktov podla abecedy cez lambdu
products.sort((p1, p2) -> p1.name.compareTo(p2.name));
// Vyfiltrovanie produktov s cenou (0.5. 1.0)
Stream<Product> filteredProducts = products.stream().filter(p -> p.price > 0.5 && p.price < 1.0);
// Iterovanie v kolekcii
filteredProducts.forEach(product -> System.out.println(product.name + ": " + product.price));
}
}Das Ergebnis, das du erhältst, sieht folgendermaßen aus:
Cokolada: 0.7
Keksy: 0.8Lambda-Ausdrücke machen die Arbeit einfacher und schneller
Lambda-Ausdrücke sind eine großartige Funktionalität in der Programmiersprache Java. Die Arbeit kann durch ihre Verwendung erleichtert und beschleunigt werden. Darüber hinaus verdeutlichen sie den Code und eröffnen neue Möglichkeiten. Lambda ist seit Java 8 ein Teil von Java. Wenn du also eine ältere Version verwendest, lohnt es sich, über ein Update nachzudenken.
Wir haben Dateien mit den oben genannten Java Lambda-Beispielen vorbereitet, die du direkt in Java ausführen kannst. Lade den Code hier herunter.
