Der Lambda-Ausdruck ist eine neue und wichtige Funktion von Java, die in Java SE 8 enthalten war. Er bietet eine klare und prägnante Möglichkeit, eine Methodenschnittstelle mithilfe eines Ausdrucks darzustellen. Es ist sehr nützlich in der Sammlungsbibliothek. Es hilft, Daten aus der Sammlung zu iterieren, zu filtern und zu extrahieren.

Der Lambda-Ausdruck wird verwendet, um die Implementierung einer Schnittstelle bereitzustellen, die über eine funktionale Schnittstelle verfügt. Es spart viel Code. Im Falle eines Lambda-Ausdrucks müssen wir die Methode nicht erneut definieren, um die Implementierung bereitzustellen. Hier schreiben wir einfach den Implementierungscode.

Der Java-Lambda-Ausdruck wird als Funktion behandelt, sodass der Compiler keine .class-Datei erstellt.

Funktionsschnittstelle

Der Lambda-Ausdruck bietet die Implementierung von funktionale Schnittstelle . Eine Schnittstelle, die nur über eine abstrakte Methode verfügt, wird als funktionale Schnittstelle bezeichnet. Java bietet eine Anmerkung @ Funktionale Schnittstelle , mit dem eine Schnittstelle als funktionale Schnittstelle deklariert wird.

Warum Lambda Expression verwenden?

1. Bereitstellung der Implementierung einer funktionalen Schnittstelle.
2. Weniger Codierung.

Java-Lambda-Ausdruckssyntax

 (argument-list) -> {body} 

Der Java-Lambda-Ausdruck besteht aus drei Komponenten.

1) Argumentenliste: Es kann auch leer oder nicht leer sein.

2) Pfeil-Token: Es wird verwendet, um die Argumentliste und den Ausdruckskörper zu verknüpfen.

3) Körper: Es enthält Ausdrücke und Anweisungen für den Lambda-Ausdruck.

manuelle Prüfung

Keine Parametersyntax

 () -> { //Body of no parameter lambda } 

Ein-Parameter-Syntax

 (p1) -> { //Body of single parameter lambda } 

Zwei-Parameter-Syntax

 (p1,p2) -> { //Body of multiple parameter lambda } 

Sehen wir uns ein Szenario an, in dem wir keinen Java-Lambda-Ausdruck implementieren. Hier implementieren wir eine Schnittstelle ohne Verwendung des Lambda-Ausdrucks.

Ohne Lambda-Ausdruck

 interface Drawable{ public void draw(); } public class LambdaExpressionExample { public static void main(String[] args) { int width=10; //without lambda, Drawable implementation using anonymous class Drawable d=new Drawable(){ public void draw(){System.out.println('Drawing '+width);} }; d.draw(); } } 

Ausgabe:

 Drawing 10 

Beispiel für einen Java-Lambda-Ausdruck

Jetzt werden wir das obige Beispiel mit Hilfe des Java-Lambda-Ausdrucks implementieren.

 @FunctionalInterface //It is optional interface Drawable{ public void draw(); } public class LambdaExpressionExample2 { public static void main(String[] args) { int width=10; //with lambda Drawable d2=()->{ System.out.println('Drawing '+width); }; d2.draw(); } } 

Ausgabe:

 Drawing 10 

Ein Lambda-Ausdruck kann null oder eine beliebige Anzahl von Argumenten haben. Sehen wir uns die Beispiele an:

Beispiel für einen Java-Lambda-Ausdruck: Kein Parameter

 interface Sayable{ public String say(); } public class LambdaExpressionExample3{ public static void main(String[] args) { Sayable s=()->{ return 'I have nothing to say.'; }; System.out.println(s.say()); } } 

Ausgabe:

Top 10 Hentai

 I have nothing to say. 

Beispiel für einen Java-Lambda-Ausdruck: Einzelner Parameter

 interface Sayable{ public String say(String name); } public class LambdaExpressionExample4{ public static void main(String[] args) { // Lambda expression with single parameter. Sayable s1=(name)->{ return 'Hello, '+name; }; System.out.println(s1.say('Sonoo')); // You can omit function parentheses Sayable s2= name ->{ return 'Hello, '+name; }; System.out.println(s2.say('Sonoo')); } } 

Ausgabe:

 Hello, Sonoo Hello, Sonoo 

Beispiel für einen Java-Lambda-Ausdruck: Mehrere Parameter

 interface Addable{ int add(int a,int b); } public class LambdaExpressionExample5{ public static void main(String[] args) { // Multiple parameters in lambda expression Addable ad1=(a,b)->(a+b); System.out.println(ad1.add(10,20)); // Multiple parameters with data type in lambda expression Addable ad2=(int a,int b)->(a+b); System.out.println(ad2.add(100,200)); } } 

Ausgabe:

 30 300 

Beispiel für einen Java-Lambda-Ausdruck: mit oder ohne Rückgabeschlüsselwort

Wenn es im Java-Lambda-Ausdruck nur eine Anweisung gibt, können Sie das Schlüsselwort return verwenden oder auch nicht. Sie müssen das Schlüsselwort return verwenden, wenn der Lambda-Ausdruck mehrere Anweisungen enthält.

 interface Addable{ int add(int a,int b); } public class LambdaExpressionExample6 { public static void main(String[] args) { // Lambda expression without return keyword. Addable ad1=(a,b)->(a+b); System.out.println(ad1.add(10,20)); // Lambda expression with return keyword. Addable ad2=(int a,int b)->{ return (a+b); }; System.out.println(ad2.add(100,200)); } } 

Ausgabe:

 30 300 

Beispiel für einen Java-Lambda-Ausdruck: Foreach-Schleife

 import java.util.*; public class LambdaExpressionExample7{ public static void main(String[] args) { List list=new ArrayList(); list.add('ankit'); list.add('mayank'); list.add('irfan'); list.add('jai'); list.forEach( (n)->System.out.println(n) ); } } 

Ausgabe:

 ankit mayank irfan jai 

Beispiel für einen Java-Lambda-Ausdruck: Mehrere Anweisungen

 @FunctionalInterface interface Sayable{ String say(String message); } public class LambdaExpressionExample8{ public static void main(String[] args) { // You can pass multiple statements in lambda expression Sayable person = (message)-> { String str1 = 'I would like to say, '; String str2 = str1 + message; return str2; }; System.out.println(person.say('time is precious.')); } } 

Ausgabe:

 I would like to say, time is precious. 

Beispiel für einen Java-Lambda-Ausdruck: Thread erstellen

Sie können den Lambda-Ausdruck verwenden, um einen Thread auszuführen. Im folgenden Beispiel implementieren wir die Ausführungsmethode mithilfe des Lambda-Ausdrucks.

 public class LambdaExpressionExample9{ public static void main(String[] args) { //Thread Example without lambda Runnable r1=new Runnable(){ public void run(){ System.out.println('Thread1 is running...'); } }; Thread t1=new Thread(r1); t1.start(); //Thread Example with lambda Runnable r2=()->{ System.out.println('Thread2 is running...'); }; Thread t2=new Thread(r2); t2.start(); } } 

Ausgabe:

 Thread1 is running... Thread2 is running... 

Der Java-Lambda-Ausdruck kann im Sammlungsframework verwendet werden. Es bietet eine effiziente und übersichtliche Möglichkeit, Daten zu iterieren, zu filtern und abzurufen. Im Folgenden finden Sie einige Lambda- und Sammlungsbeispiele.

Java liest die Datei Zeile für Zeile

Beispiel für einen Java-Lambda-Ausdruck: Komparator

 import java.util.ArrayList; import java.util.Collections; import java.util.List; class Product{ int id; String name; float price; public Product(int id, String name, float price) { super(); this.id = id; this.name = name; this.price = price; } } public class LambdaExpressionExample10{ public static void main(String[] args) { List list=new ArrayList(); //Adding Products list.add(new Product(1,'HP Laptop',25000f)); list.add(new Product(3,'Keyboard',300f)); list.add(new Product(2,'Dell Mouse',150f)); System.out.println('Sorting on the basis of name...'); // implementing lambda expression Collections.sort(list,(p1,p2)->{ return p1.name.compareTo(p2.name); }); for(Product p:list){ System.out.println(p.id+' '+p.name+' '+p.price); } } } 

Ausgabe:

 Sorting on the basis of name... 2 Dell Mouse 150.0 1 HP Laptop 25000.0 3 Keyboard 300.0 

Beispiel für einen Java-Lambda-Ausdruck: Sammlungsdaten filtern

 import java.util.ArrayList; import java.util.List; import java.util.stream.Stream; class Product{ int id; String name; float price; public Product(int id, String name, float price) { super(); this.id = id; this.name = name; this.price = price; } } public class LambdaExpressionExample11{ public static void main(String[] args) { List list=new ArrayList(); list.add(new Product(1,'Samsung A5',17000f)); list.add(new Product(3,'Iphone 6S',65000f)); list.add(new Product(2,'Sony Xperia',25000f)); list.add(new Product(4,'Nokia Lumia',15000f)); list.add(new Product(5,'Redmi4 ',26000f)); list.add(new Product(6,'Lenevo Vibe',19000f)); // using lambda to filter data Stream filtered_data = list.stream().filter(p -> p.price > 20000); // using lambda to iterate through collection filtered_data.forEach( product -> System.out.println(product.name+': '+product.price) ); } } 

Ausgabe:

 Iphone 6S: 65000.0 Sony Xperia: 25000.0 Redmi4 : 26000.0 

Beispiel für einen Java-Lambda-Ausdruck: Ereignis-Listener

 import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JTextField; public class LambdaEventListenerExample { public static void main(String[] args) { JTextField tf=new JTextField(); tf.setBounds(50, 50,150,20); JButton b=new JButton('click'); b.setBounds(80,100,70,30); // lambda expression implementing here. b.addActionListener(e-> {tf.setText('hello swing');}); JFrame f=new JFrame(); f.add(tf);f.add(b); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); f.setLayout(null); f.setSize(300, 200); f.setVisible(true); } } 

Ausgabe: