logo

TechCodeview

Expressió Lambda en Java

A Java, les expressions Lambda expressen bàsicament instàncies d'interfícies funcionals (una interfície amb un únic mètode abstracte s'anomena interfície funcional). Les expressions Lambda a Java són les mateixes que les funcions lambda, que són el bloc curt de codi que accepta l'entrada com a paràmetres i retorna un valor resultant. Les expressions Lambda s'han inclòs recentment a Java SE 8.

Funcionalitats de l'expressió Lambda a Java

Expressions Lambda implementen l'única funció abstracta i, per tant, implementen interfícies funcionals. Les expressions lambda s'afegeixen a Java 8 i proporcionen les funcionalitats següents.



  • Habilita per tractar la funcionalitat com un argument de mètode o el codi com a dades.
  • Una funció que es pot crear sense pertànyer a cap classe.
  • Es pot passar una expressió lambda com si fos un objecte i executar-se sota demanda.

Exemple d'expressió Lambda de Java

Java 
// 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);  // Això crida a l'expressió lambda anterior i imprimeix 10. fobj.abstractFun(5);  } }>>>  
  Sortida  
10>
  
 expressió lambdaSintaxi d'expressió lambda
Hi ha tres paràmetres d'expressió Lambda que s'esmenten a continuació:
 
  1. Paràmetre zero
  2. Paràmetre únic
  3. Múltiples paràmetres
    1. Expressió lambda amb paràmetre zero    
>>
    2. Expressió Lambda amb paràmetre únic    
>>
No és obligatori utilitzar parèntesis si el tipus d'aquesta variable es pot inferir del context
Java 
// 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 = nova ArrayList ();  arrL.add(1);  arrL.add(2);  arrL.add(3);  arrL.add(4);  // Utilitzant l'expressió lambda per imprimir tots els elements // de arrL arrL.forEach(n -> System.out.println(n));  // Utilitzant l'expressió lambda per imprimir elements parells // de arrL arrL.forEach(n -> { if (n % 2 == 0) System.out.println(n); });  } }>>>  
  Sortida      Nota:         que les expressions lambda només es poden utilitzar per implementar interfícies funcionals. A l'exemple anterior també s'implementa l'expressió lambda         Consumidor         Interfície funcional.    
 
 

 
    3. Expressió Lambda amb múltiples paràmetres    
>>
Un programa Java per demostrar el funcionament d'una expressió lambda amb dos arguments.
Java 
// 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;  // Multiplicació de l'expressió lambda per a dos // paràmetres Aquesta expressió també implementa // la interfície 'FuncInter1' FuncInter1 multiplicar = (int x, int y) -> x * y;  // Creació d'un objecte de Test per cridar a operate utilitzant // diferents implementacions utilitzant lambda // Expressions Test tobj = new Test();  // Afegeix dos nombres utilitzant l'expressió lambda System.out.println('L'addició és ' + tobj.operate(6, 3, suma));  // Multiplica dos nombres utilitzant l'expressió lambda System.out.println('La multiplicació és ' + tobj.operate(6, 3, multiplicar));  // Expressió lambda per a un paràmetre únic // Aquesta expressió implementa la interfície 'FuncInter2' FuncInter2 fobj = message -> System.out.println('Hola ' + missatge);  fobj.sayMessage('Geek');  } }>>>  
  Sortida      Nota:         Les expressions lambda són com les funcions i accepten paràmetres igual que les funcions.    
 
Conclusió
A continuació s'esmenten alguns punts importants d'aquest article:
 
 

 
  • El cos d'una expressió lambda pot contenir zero, una o més declaracions.
  • Quan hi ha una sola instrucció, els claudàtors no són obligatoris i el tipus de retorn de la funció anònima és el mateix que el de l'expressió corporal.
  • Quan hi ha més d'una instrucció, aquestes s'han d'entregar entre claudàtors (un bloc de codi) i el tipus de retorn de la funció anònima és el mateix que el tipus del valor retornat dins del bloc de codi, o nul si no es retorna res. .
Preguntes freqüents a Lambda Expression
Q1. Quin tipus d'expressió lambda Java?
    Resposta:    
  
Les expressions Lambda de Java són el bloc curt de codi que accepta entrada com a paràmetres i retorna un valor resultant.
 
P2. És bo utilitzar expressions lambda a Java?
    Resposta:    
  
Sí, l'ús d'expressions lambda facilita l'ús i el suport d'altres API.
 
P3. Quins són els inconvenients de Java lambda?
    Resposta:    
  
Les funcions lambda de Java només es poden utilitzar amb interfícies funcionals.
 
P4. D'acord amb les regles de sintaxi que s'acaben de mostrar, quina de les següents NO són ​​expressions lambda vàlides?
  1.     () -> {}    
  2.     () -> geeksforgeeks    
  3.     () -> { return geeksforgeeks;}    
  4.     (Enter i) -> retorna geeksforgeeks + i;    
  5.     (Cadena s) -> {geeksforgeeks;}    
Resposta:
 
4 i 5 són lambdas no vàlides, la resta són vàlides. Detalls:
 
  1. Aquesta lambda no té paràmetres i retorna void. És similar a un mètode amb un cos buit: public void run() { }.
  2. Aquesta lambda no té paràmetres i retorna una cadena com a expressió.
  3. Aquesta lambda no té paràmetres i retorna una cadena (utilitzant una instrucció de retorn explícita, dins d'un bloc).
  4. retorn és una instrucció de flux de control. Perquè aquesta lambda sigui vàlida, calen claus de la manera següent: (Enter i) -> { return geeksforgeeks + i; }.
  5. geeks for geeks és una expressió, no una afirmació. Perquè aquesta lambda sigui vàlida, podeu eliminar les claus i el punt i coma de la següent manera: (String s) -> geeks for geeks. O si ho preferiu, podeu utilitzar una declaració de retorn explícita de la següent manera: (String s) -> { return geeks for geeks; }.