L'espressione Lambda è una nuova e importante funzionalità di Java inclusa in Java SE 8. Fornisce un modo chiaro e conciso per rappresentare l'interfaccia di un metodo utilizzando un'espressione. È molto utile nella libreria di raccolte. Aiuta a ripetere, filtrare ed estrarre i dati dalla raccolta.

L'espressione Lambda viene utilizzata per fornire l'implementazione di un'interfaccia dotata di interfaccia funzionale. Risparmia molto codice. In caso di espressione lambda, non è necessario definire nuovamente il metodo per fornire l'implementazione. Qui scriviamo semplicemente il codice di implementazione.

L'espressione lambda Java viene trattata come una funzione, quindi il compilatore non crea il file .class.

Interfaccia funzionale

L'espressione Lambda fornisce l'implementazione di interfaccia funzionale . Un'interfaccia che ha un solo metodo astratto è chiamata interfaccia funzionale. Java fornisce un'annotazione @ Interfaccia funzionale , che viene utilizzato per dichiarare un'interfaccia come interfaccia funzionale.

Perché utilizzare l'espressione Lambda

1. Fornire l'implementazione dell'interfaccia funzionale.
2. Meno codifica.

Sintassi dell'espressione Java Lambda

 (argument-list) -> {body} 

L'espressione lambda Java è composta da tre componenti.

1) Elenco degli argomenti: Può essere anche vuoto o non vuoto.

2) Gettone-freccia: Viene utilizzato per collegare l'elenco degli argomenti e il corpo dell'espressione.

3) Corpo: Contiene espressioni e istruzioni per l'espressione lambda.

Nessuna sintassi dei parametri

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

Sintassi di un parametro

stringa in char java

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

Sintassi a due parametri

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

Vediamo uno scenario in cui non stiamo implementando l'espressione lambda Java. Qui stiamo implementando un'interfaccia senza utilizzare l'espressione lambda.

Senza espressione Lambda

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

Produzione:

 Drawing 10 

Esempio di espressione Java Lambda

Ora implementeremo l'esempio precedente con l'aiuto dell'espressione lambda Java.

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

Produzione:

 Drawing 10 

Un'espressione lambda può avere zero o un numero qualsiasi di argomenti. Vediamo gli esempi:

Esempio di espressione Java Lambda: nessun parametro

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

Produzione:

 I have nothing to say. 

Esempio di espressione Java Lambda: parametro singolo

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

Produzione:

 Hello, Sonoo Hello, Sonoo 

Esempio di espressione Java Lambda: parametri multipli

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

Produzione:

 30 300 

Esempio di espressione Java Lambda: con o senza parola chiave return

Nell'espressione lambda Java, se è presente una sola istruzione, è possibile utilizzare o meno la parola chiave return. È necessario utilizzare la parola chiave return quando l'espressione lambda contiene più istruzioni.

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

Produzione:

 30 300 

Esempio di espressione Java Lambda: ciclo Foreach

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

Produzione:

 ankit mayank irfan jai 

Esempio di espressione Java Lambda: istruzioni multiple

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

Produzione:

 I would like to say, time is precious. 

Esempio di espressione Java Lambda: creazione di thread

È possibile utilizzare l'espressione lambda per eseguire il thread. Nell'esempio seguente stiamo implementando il metodo run utilizzando l'espressione lambda.

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

Produzione:

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

L'espressione lambda Java può essere utilizzata nel framework della raccolta. Fornisce un modo efficiente e conciso per iterare, filtrare e recuperare i dati. Di seguito sono forniti alcuni esempi di lambda e raccolte.

Esempio di espressione Java Lambda: comparatore

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

Produzione:

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

Esempio di espressione Java Lambda: filtro dei dati di raccolta

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

Produzione:

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

Esempio di espressione Java Lambda: ascoltatore di eventi

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

Produzione: