Lambda-expressie is een nieuwe en belangrijke functie van Java die is opgenomen in Java SE 8. Het biedt een duidelijke en beknopte manier om één methode-interface weer te geven met behulp van een expressie. Het is erg handig in de collectiebibliotheek. Het helpt bij het herhalen, filteren en extraheren van gegevens uit de verzameling.

De Lambda-expressie wordt gebruikt om de implementatie te bieden van een interface met een functionele interface. Het bespaart veel code. In het geval van lambda-expressie hoeven we de methode niet opnieuw te definiëren voor het leveren van de implementatie. Hier schrijven we alleen de implementatiecode.

De Java lambda-expressie wordt behandeld als een functie, dus de compiler maakt geen .class-bestand.

Functionele interface

Lambda-expressie biedt implementatie van functionele interface . Een interface die slechts één abstracte methode heeft, wordt functionele interface genoemd. Java biedt een annotatie @ Functionele interface , die wordt gebruikt om een ​​interface als functionele interface te declareren.

Waarom Lambda-expressie gebruiken?

1. Het verzorgen van de implementatie van de functionele interface.
2. Minder codering.

Syntaxis van Java Lambda-expressie

 (argument-list) -> {body} 

Java lambda-expressie bestaat uit drie componenten.

Java-lijstreeks

1) Argumentenlijst: Het kan ook leeg of niet-leeg zijn.

2) Pijlfiche: Het wordt gebruikt om de argumentenlijst en de hoofdtekst te koppelen.

3) Lichaam: Het bevat uitdrukkingen en instructies voor lambda-expressie.

Geen parametersyntaxis

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

Eén parametersyntaxis

aaneenschakeling van Java-tekenreeksen

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

Syntaxis van twee parameters

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

Laten we een scenario bekijken waarin we de Java lambda-expressie niet implementeren. Hier implementeren we een interface zonder gebruik te maken van lambda-expressie.

js onclick

Zonder Lambda-expressie

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

Uitgang:

 Drawing 10 

Voorbeeld van Java Lambda-expressie

Nu gaan we het bovenstaande voorbeeld implementeren met behulp van Java lambda-expressie.

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

Uitgang:

 Drawing 10 

Een lambda-expressie kan nul of een willekeurig aantal argumenten bevatten. Laten we de voorbeelden bekijken:

hashmap-java

Voorbeeld van Java Lambda-expressie: Geen 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()); } } 

Uitgang:

 I have nothing to say. 

Voorbeeld van Java Lambda-expressie: enkele 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')); } } 

Uitgang:

 Hello, Sonoo Hello, Sonoo 

Voorbeeld van Java Lambda-expressie: meerdere parameters

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

Uitgang:

 30 300 

Java Lambda-expressie Voorbeeld: met of zonder return-trefwoord

Als er in de Java lambda-expressie slechts één instructie is, kunt u wel of niet het return-trefwoord gebruiken. U moet het return-trefwoord gebruiken als de lambda-expressie meerdere instructies bevat.

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

Uitgang:

 30 300 

Voorbeeld van Java Lambda-expressie: Foreach-lus

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

Uitgang:

 ankit mayank irfan jai 

Voorbeeld van Java Lambda-expressie: meerdere instructies

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

Uitgang:

 I would like to say, time is precious. 

Voorbeeld van Java Lambda-expressie: Thread maken

U kunt de lambda-expressie gebruiken om thread uit te voeren. In het volgende voorbeeld implementeren we de run-methode met behulp van de lambda-expressie.

Rudyard Kipling als uitleg

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

Uitgang:

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

Java lambda-expressie kan worden gebruikt in het verzamelingsframework. Het biedt een efficiënte en beknopte manier om gegevens te herhalen, filteren en ophalen. Hieronder volgen enkele lambda- en verzamelvoorbeelden.

Voorbeeld van Java Lambda-expressie: Comparator

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

Uitgang:

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

Voorbeeld van Java Lambda-expressie: Verzamelgegevens filteren

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

Uitgang:

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

Voorbeeld van Java Lambda-expressie: gebeurtenislistener

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

Uitgang: