In Java drukken Lambda-expressies in feite gevallen uit van functionele interfaces (een interface met een enkele abstracte methode wordt een functionele interface genoemd). Lambda-expressies in Java zijn hetzelfde als lambda-functies, het korte codeblok dat invoer als parameters accepteert en een resulterende waarde retourneert. Lambda-expressies zijn onlangs opgenomen in Java SE 8.

Functionaliteiten van Lambda-expressie in Java

Lambda-expressies implementeren de enige abstracte functie en implementeren daarom functionele interfaces. Lambda-expressies zijn toegevoegd in Java 8 en bieden de onderstaande functionaliteiten.

• Schakel in om functionaliteit te behandelen als een methodeargument, of code als gegevens.
• Een functie die kan worden gemaakt zonder tot een klasse te behoren.
• Een lambda-expressie kan worden doorgegeven alsof het een object is en op verzoek worden uitgevoerd.

Voorbeeld van Java Lambda-expressie

// 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)->Systeem.uit.println(2*x);  // Dit roept bovenstaande lambda-expressie op en print 10. fobj.abstractFun(5);  } }>

10>

Lambda-expressiesyntaxis

 lambda operator ->lichaam>

Lambda-expressieparameters

Er zijn drie Lambda-expressieparameters die hieronder worden vermeld:

1. Nulparameter
2. Enkele parameter
3. Meerdere parameters

1. Lambda-expressie met nulparameter

() ->System.out.println('Nul parameter lambda');>

2. Lambda-expressie met enkele parameter

(p) ->System.out.println('Eén parameter: ' + p);>

Het is niet verplicht om haakjes te gebruiken als het type van die variabele uit de context kan worden afgeleid

// 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 = nieuwe ArrayList ();  arrL.add(1);  arrL.add(2);  arrL.add(3);  arrL.add(4);  // Lambda-expressie gebruiken om alle elementen af ​​te drukken // van arrL arrL.forEach(n -> System.out.println(n));  // Lambda-expressie gebruiken om even elementen af ​​te drukken // van arrL arrL.forEach(n -> { if (n % 2 == 0) System.out.println(n); });  } }>

1 2 3 4 2 4>

Opmerking: dat lambda-expressies alleen kunnen worden gebruikt om functionele interfaces te implementeren. In het bovenstaande voorbeeld wordt ook de lambda-expressie geïmplementeerd Klant Functionele interface.

3. Lambda-expressie met meerdere parameters

(p1, p2) ->System.out.println('Meerdere parameters: ' + p1 + ', ' + p2);>

Een Java-programma om de werking van een lambda-expressie met twee argumenten te demonstreren.

// 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;  // lambda-expressievermenigvuldiging voor twee // parameters Deze expressie implementeert ook // 'FuncInter1' interface FuncInter1 multiply = (int x, int y) -> x * y;  // Een object van Test maken om te bellen met // verschillende implementaties met behulp van lambda // Expressies Test tobj = new Test();  // Voeg twee getallen toe met behulp van de lambda-expressie System.out.println('Optelling is ' + tobj.operate(6, 3, add));  // Vermenigvuldig twee getallen met behulp van de lambda-expressie System.out.println('Vermenigvuldiging is ' + tobj.operate(6, 3, vermenigvuldigen));  // lambda-expressie voor één parameter // Deze expressie implementeert de 'FuncInter2'-interface FuncInter2 fobj = bericht -> System.out.println('Hallo ' + bericht);  fobj.sayMessage('Geek');  } }>

Addition is 9 Multiplication is 18 Hello Geek>

Opmerking: Lambda-expressies zijn net als functies en accepteren parameters net als functies.

Conclusie

Enkele belangrijke punten uit dit artikel worden hieronder vermeld:

• De hoofdtekst van een lambda-expressie kan nul, één of meer instructies bevatten.
• Als er een enkele instructie is, zijn accolades niet verplicht en is het retourtype van de anonieme functie hetzelfde als dat van de hoofdexpressie.
• Als er meer dan één instructie is, moeten deze tussen accolades staan ​​(een codeblok) en is het retourtype van de anonieme functie hetzelfde als het type waarde dat wordt geretourneerd binnen het codeblok, of ongeldig als er niets wordt geretourneerd .

Veelgestelde vragen over Lambda Expression

Q1. Welk type lambda-expressie Java?

Antwoord:

Java Lambda-expressies zijn het korte codeblok dat invoer als parameters accepteert en een resulterende waarde retourneert.

Vraag 2. Is het goed om lambda-expressies in Java te gebruiken?

Antwoord:

Ja, het gebruik van lambda-expressies maakt het eenvoudiger om andere API's te gebruiken en te ondersteunen.

Q3. Wat zijn de nadelen van Java-lambda?

Antwoord:

Java lambda-functies kunnen alleen worden gebruikt met functionele interfaces.

Q4. Gebaseerd op de zojuist getoonde syntaxisregels, welke van de volgende is/zijn GEEN geldige lambda-expressies?

1. () -> {}
2. () -> geeksforgeeks
3. () -> { return geeksforgeeks;}
4. (Geheel getal i) -> return geeksforgeeks + i;
5. (String s) -> {geeksforgeeks;}

Antwoord:

4 en 5 zijn ongeldige lambda's, de rest is geldig. Details:

1. Deze lambda heeft geen parameters en retourneert ongeldig. Het is vergelijkbaar met een methode met een lege body: public void run() { }.
2. Deze lambda heeft geen parameters en retourneert een String als expressie.
3. Deze lambda heeft geen parameters en retourneert een String (met behulp van een expliciete return-instructie, binnen een blok).
4. return is een control-flow-instructie. Om deze lambda geldig te maken, zijn accolades als volgt vereist: (Geheel getal i) -> { return geeksforgeeks + i; }.
5. geeks voor geeks is een uitdrukking, geen verklaring. Om deze lambda geldig te maken, kunt u de accolades en de puntkomma als volgt verwijderen: (String s) -> geeks voor geeks. Of als je dat liever hebt, kun je als volgt een expliciete return-instructie gebruiken: (String s) -> { return geeks for geeks; }.