In Java, le espressioni Lambda esprimono fondamentalmente istanze di interfacce funzionali (un'interfaccia con un singolo metodo astratto è chiamata interfaccia funzionale). Le espressioni Lambda in Java sono le stesse delle funzioni lambda che sono il breve blocco di codice che accetta input come parametri e restituisce un valore risultante. Le espressioni Lambda sono state recentemente incluse in Java SE 8.

Funzionalità dell'espressione Lambda in Java

Le espressioni lambda implementano l'unica funzione astratta e quindi implementano interfacce funzionali. Le espressioni lambda vengono aggiunte in Java 8 e forniscono le funzionalità seguenti.

• Abilita per trattare la funzionalità come argomento del metodo o il codice come dati.
• Una funzione che può essere creata senza appartenere ad alcuna classe.
• Un'espressione lambda può essere passata come se fosse un oggetto ed eseguita su richiesta.

Esempio di espressione Java Lambda

// Java program to demonstrate lambda expressions // to implement a user defined functional interface. // A sample functional interface (An interface with // single abstract method interface FuncInterface {  // An abstract function  void abstractFun(int x);  // A non-abstract (or default) function  default void normalFun()  {  System.out.println('Hello');  } } class Test {  public static void main(String args[])  {  // lambda expression to implement above  // functional interface. This interface  // by default implements abstractFun()  FuncInterface fobj = (int x)->System.out.println(2*x);  // Questo richiama l'espressione lambda sopra e stampa 10. fobj.abstractFun(5);  } }>

10>

Sintassi dell'espressione Lambda

 lambda operator ->corpo>

Parametri dell'espressione Lambda

Esistono tre parametri di espressione Lambda menzionati di seguito:

1. Parametro zero
2. Parametro singolo
3. Parametri multipli

1. Espressione Lambda con parametro Zero

() ->System.out.println('Parametro zero lambda');>

2. Espressione Lambda con parametro singolo

(p) ->System.out.println('Un parametro: ' + p);>

Non è obbligatorio utilizzare le parentesi se il tipo di quella variabile può essere dedotto dal contesto

// A Java program to demonstrate simple lambda expressions import java.util.ArrayList; class Test {  public static void main(String args[])  {  // Creating an ArrayList with elements  // {1, 2, 3, 4}  ArrayList arrL = nuovo ArrayList ();  arrL.add(1);  arrL.add(2);  arrL.add(3);  arrL.add(4);  // Utilizzo dell'espressione lambda per stampare tutti gli elementi // di arrL arrL.forEach(n -> System.out.println(n));  // Utilizzo dell'espressione lambda per stampare elementi pari // di arrL arrL.forEach(n -> { if (n % 2 == 0) System.out.println(n); });  } }>

1 2 3 4 2 4>

Nota: che le espressioni lambda possono essere utilizzate solo per implementare interfacce funzionali. Anche nell'esempio precedente, l'espressione lambda implementa Consumatore Interfaccia funzionale.

3. Espressione Lambda con parametri multipli

(p1, p2) ->System.out.println('Parametri multipli: ' + p1 + ', ' + p2);>

Un programma Java per dimostrare il funzionamento di un'espressione lambda con due argomenti.

// Java program to demonstrate working of lambda expressions public class Test {  // operation is implemented using lambda expressions  interface FuncInter1 {  int operation(int a, int b);  }  // sayMessage() is implemented using lambda expressions  // above  interface FuncInter2 {  void sayMessage(String message);  }  // Performs FuncInter1's operation on 'a' and 'b'  private int operate(int a, int b, FuncInter1 fobj)  {  return fobj.operation(a, b);  }  public static void main(String args[])  {  // lambda expression for addition for two parameters  // data type for x and y is optional.  // This expression implements 'FuncInter1' interface  FuncInter1 add = (int x, int y) ->x + y;  // Moltiplicazione dell'espressione lambda per due // parametri Questa espressione implementa anche // l'interfaccia 'FuncInter1' FuncInter1 multiply = (int x, int y) -> x * y;  // Creazione di un oggetto Test per chiamare operate utilizzando // diverse implementazioni utilizzando lambda // Espressioni Test tobj = new Test();  // Aggiunge due numeri utilizzando l'espressione lambda System.out.println('L'addizione è ' + tobj.operate(6, 3, add));  // Moltiplica due numeri utilizzando l'espressione lambda System.out.println('La moltiplicazione è ' + tobj.operate(6, 3, moltiplica));  // Espressione lambda per singolo parametro // Questa espressione implementa l'interfaccia 'FuncInter2' FuncInter2 fobj = messaggio -> System.out.println('Hello ' + messaggio);  fobj.sayMessage('Geek');  } }>

Addition is 9 Multiplication is 18 Hello Geek>

Nota: Le espressioni lambda sono proprio come le funzioni e accettano parametri proprio come le funzioni.

Conclusione

Alcuni punti importanti tratti da questo articolo sono menzionati di seguito:

• Il corpo di un'espressione lambda può contenere zero, una o più istruzioni.
• Quando è presente una sola istruzione le parentesi graffe non sono obbligatorie e il tipo restituito dalla funzione anonima è lo stesso dell'espressione del corpo.
• Quando è presente più di un'istruzione, queste devono essere racchiuse tra parentesi graffe (un blocco di codice) e il tipo restituito della funzione anonima è lo stesso del tipo del valore restituito all'interno del blocco di codice, oppure void se non viene restituito nulla .

Domande frequenti sull'espressione Lambda

Q1. Che tipo di espressione lambda Java?

Risposta:

Le espressioni Java Lambda sono il breve blocco di codice che accetta input come parametri e restituisce un valore risultante.

Q2. È utile utilizzare le espressioni lambda in Java?

Risposta:

Sì, l'utilizzo delle espressioni lambda semplifica l'utilizzo e il supporto di altre API.

Q3. Quali sono gli svantaggi di Java lambda?

Risposta:

Le funzioni lambda Java possono essere utilizzate solo con interfacce funzionali.

Q4. In base alle regole di sintassi appena mostrate, quale delle seguenti NON è/sono espressioni lambda valide?

1. () -> {}
2. () -> geeksforgeeks
3. () -> { return geeksforgeeks;}
4. (Intero i) -> return geeksforgeeks + i;
5. (Stringa s) -> {geeksforgeeks;}

Risposta:

4 e 5 sono lambda non validi, il resto è valido. Dettagli:

1. Questa lambda non ha parametri e restituisce void. È simile a un metodo con un corpo vuoto: public void run() { }.
2. Questo lambda non ha parametri e restituisce una stringa come espressione.
3. Questo lambda non ha parametri e restituisce una stringa (utilizzando un'istruzione return esplicita, all'interno di un blocco).
4. return è un'istruzione del flusso di controllo. Per rendere valido questo lambda, sono necessarie le parentesi graffe come segue: (Intero i) -> { return geeksforgeeks + i; }.
5. geek per geek è un'espressione, non un'affermazione. Per rendere valido questo lambda, puoi rimuovere le parentesi graffe e il punto e virgola come segue: (String s) -> geeks for geeks. Oppure, se preferisci, puoi utilizzare un'istruzione return esplicita come segue: (String s) -> { return geeks for geeks; }.