I Java uttrycker Lambda-uttryck i princip instanser av funktionella gränssnitt (Ett gränssnitt med en enda abstrakt metod kallas ett funktionellt gränssnitt). Lambda-uttryck i Java är samma som lambda-funktioner som är det korta kodblocket som accepterar indata som parametrar och returnerar ett resulterande värde. Lambda Expressions ingår nyligen i Java SE 8.

Funktioner för Lambda Expression i Java

Lambda-uttryck implementerar den enda abstrakta funktionen och implementerar därför funktionella gränssnitt lambda-uttryck läggs till i Java 8 och tillhandahåller nedanstående funktioner.

• Aktivera för att behandla funktionalitet som ett metodargument, eller kod som data.
• En funktion som kan skapas utan att tillhöra någon klass.
• Ett lambdauttryck kan skickas runt som om det vore ett objekt och exekveras på begäran.

Exempel på Java Lambda-uttryck

// 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);  // Detta anropar ovan lambda uttryck och skriver ut 10. fobj.abstractFun(5);  } }>

10>

Lambda-uttryckssyntax

 lambda operator ->kropp>

Lambdauttrycksparametrar

Det finns tre lambdauttrycksparametrar som nämns nedan:

1. Nollparameter
2. Enkel parameter
3. Flera parametrar

1. Lambdauttryck med nollparameter

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

2. Lambdauttryck med enstaka parameter

(p) ->System.out.println('En parameter: ' + p);>

Det är inte obligatoriskt att använda parentes om typen av den variabeln kan härledas från sammanhanget

// 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 = ny ArrayList ();  arrL.add(1);  arrL.add(2);  arrL.add(3);  arrL.add(4);  // Använda lambda-uttryck för att skriva ut alla element // av arrL arrL.forEach(n -> System.out.println(n));  // Använda lambda-uttryck för att skriva ut jämna element // av arrL arrL.forEach(n -> { if (n % 2 == 0) System.out.println(n); });  } }>

1 2 3 4 2 4>

Notera: att lambda-uttryck endast kan användas för att implementera funktionella gränssnitt. I exemplet ovan implementeras också lambda-uttrycket Konsument Funktionellt gränssnitt.

3. Lambdauttryck med flera parametrar

(p1, p2) ->System.out.println('Flera parametrar: ' + p1 + ', ' + p2);>

Ett Java-program för att visa hur ett lambda-uttryck fungerar med två argument.

// 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 uttryck multiplikation för två // parametrar Detta uttryck implementerar också // 'FuncInter1' gränssnitt FuncInter1 multiplicerar = (int x, int y) -> x * y;  // Skapa ett objekt av Test att anropa använda // olika implementeringar med lambda // Expressions Test tobj = new Test();  // Lägg till två tal med lambda-uttryck System.out.println('Addition är ' + tobj.operate(6, 3, add));  // Multiplicera två tal med lambda-uttryck System.out.println('Multiplikation är ' + tobj.operate(6, 3, multiplicera));  // lambda uttryck för enstaka parameter // Detta uttryck implementerar 'FuncInter2' gränssnitt FuncInter2 fobj = meddelande -> System.out.println('Hej ' + meddelande);  fobj.sayMessage('Nörd');  } }>

Addition is 9 Multiplication is 18 Hello Geek>

Notera: Lambda-uttryck är precis som funktioner och de accepterar parametrar precis som funktioner.

Slutsats

Några viktiga poängintag från den här artikeln nämns nedan:

• Brödtexten i ett lambda-uttryck kan innehålla noll, ett eller flera påståenden.
• När det finns ett enda uttalande är klammer inte obligatoriska och returtypen för den anonyma funktionen är densamma som för kroppsuttrycket.
• När det finns mer än en sats måste dessa omges av parenteser (ett kodblock) och returtypen för den anonyma funktionen är densamma som typen av värdet som returneras inom kodblocket, eller ogiltig om inget returneras .

Vanliga frågor i Lambda Expression

Q1. Vilken typ av lambdauttryck Java?

Svar:

Java Lambda Expressions är det korta kodblocket som accepterar indata som parametrar och returnerar ett resulterande värde.

Q2. Är det bra att använda lambda-uttryck i Java?

Svar:

Ja, att använda lambda-uttryck gör det lättare att använda och stödja andra API:er.

Q3. Vilka är nackdelarna med Java lambda?

Svar:

Java lambda-funktioner kan endast användas med funktionella gränssnitt.

Q4. Baserat på syntaxreglerna som just visas, vilket av följande är INTE giltiga lambda-uttryck?

1. () -> {}
2. () -> geeksforgeeks
3. () -> { return geeksforgeeks;}
4. (Heltal i) -> returnera geeksforgeeks + i;
5. (Sträng s) -> {geeksforgeeks;}

Svar:

4 och 5 är ogiltiga lambdas, resten är giltiga. Detaljer:

1. Denna lambda har inga parametrar och returnerar void. Det liknar en metod med en tom kropp: public void run() { }.
2. Denna lambda har inga parametrar och returnerar en sträng som ett uttryck.
3. Denna lambda har inga parametrar och returnerar en sträng (med en explicit retursats, inom ett block).
4. retur är ett kontrollflödesuttalande. För att göra denna lambda giltig krävs lockiga hängslen enligt följande: (heltal i) -> { return geeksforgeeks + i; }.
5. nördar för nördar är ett uttryck, inte ett påstående. För att göra denna lambda giltig kan du ta bort de lockiga hängslen och semikolon enligt följande: (String s) -> nördar för nördar. Eller om du föredrar det kan du använda en uttrycklig retursats enligt följande: (String s) -> { return geeks for geeks; }.