En Java, les expressions Lambda expriment essentiellement des instances d'interfaces fonctionnelles (une interface avec une seule méthode abstraite est appelée interface fonctionnelle). Les expressions Lambda en Java sont identiques aux fonctions lambda qui sont le court bloc de code qui accepte les entrées en tant que paramètres et renvoie une valeur résultante. Les expressions Lambda sont récemment incluses dans Java SE 8.

Fonctionnalités de l'expression Lambda en Java

Les expressions Lambda implémentent la seule fonction abstraite et implémentent donc des interfaces fonctionnelles. Les expressions lambda sont ajoutées dans Java 8 et fournissent les fonctionnalités ci-dessous.

• Permet de traiter la fonctionnalité comme un argument de méthode ou le code comme des données.
• Une fonction qui peut être créée sans appartenir à aucune classe.
• Une expression lambda peut être transmise comme s'il s'agissait d'un objet et exécutée à la demande.

Exemple d'expression 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);  // Ceci appelle l'expression lambda ci-dessus et imprime 10. fobj.abstractFun(5);  } }>

10>

Syntaxe des expressions Lambda

 lambda operator ->corps>

Paramètres d'expression lambda

Il existe trois paramètres d'expression Lambda mentionnés ci-dessous :

1. Paramètre zéro
2. Paramètre unique
3. Paramètres multiples

1. Expression Lambda avec paramètre zéro

() ->System.out.println('Paramètre zéro lambda');>

2. Expression Lambda avec paramètre unique

(p) ->System.out.println('Un paramètre : ' + p);>

Il n'est pas obligatoire d'utiliser des parenthèses si le type de cette variable peut être déduit du contexte

// 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 = nouvelle liste de tableaux ();  arrL.add(1);  arrL.add(2);  arrL.add(3);  arrL.add(4);  // Utilisation de l'expression lambda pour imprimer tous les éléments // de arrL arrL.forEach(n -> System.out.println(n));  // Utilisation d'une expression lambda pour imprimer des éléments pairs // de arrL arrL.forEach(n -> { if (n % 2 == 0) System.out.println(n); });  } }>

1 2 3 4 2 4>

Note: que les expressions lambda ne peuvent être utilisées que pour implémenter des interfaces fonctionnelles. Dans l'exemple ci-dessus également, l'expression lambda implémente Consommateur Interface fonctionnelle.

3. Expression Lambda avec plusieurs paramètres

(p1, p2) ->System.out.println('Paramètres multiples : ' + p1 + ', ' + p2);>

Un programme Java pour démontrer le fonctionnement d'une expression lambda avec deux arguments.

// 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 + oui ;  // multiplication d'expression lambda pour deux // paramètres Cette expression implémente également // l'interface 'FuncInter1' FuncInter1 multiplie = (int x, int y) -> x * y;  // Création d'un objet Test à appeler à l'aide // de différentes implémentations utilisant lambda // Expressions Test tobj = new Test();  // Ajoutez deux nombres à l'aide de l'expression lambda System.out.println('Addition is ' + tobj.operate(6, 3, add));  // Multipliez deux nombres à l'aide de l'expression lambda System.out.println('La multiplication est ' + tobj.operate(6, 3, multiplie));  // Expression lambda pour un seul paramètre // Cette expression implémente l'interface 'FuncInter2' FuncInter2 fobj = message -> System.out.println('Hello ' + message);  fobj.sayMessage('Geek');  } }>

Addition is 9 Multiplication is 18 Hello Geek>

Note: Les expressions Lambda sont comme des fonctions et acceptent des paramètres comme des fonctions.

Conclusion

Certains points importants tirés de cet article sont mentionnés ci-dessous :

• Le corps d'une expression lambda peut contenir zéro, une ou plusieurs instructions.
• Lorsqu'il existe une seule instruction, les accolades ne sont pas obligatoires et le type de retour de la fonction anonyme est le même que celui de l'expression du corps.
• Lorsqu'il y a plus d'une instruction, celles-ci doivent être placées entre accolades (un bloc de code) et le type de retour de la fonction anonyme est le même que le type de la valeur renvoyée dans le bloc de code, ou nul si rien n'est renvoyé. .

FAQ sur les expressions Lambda

T1. Quel type d’expression lambda Java ?

Répondre:

Les expressions Java Lambda sont le court bloc de code qui accepte les entrées en tant que paramètres et renvoie une valeur résultante.

Q2. Est-il bon d’utiliser des expressions lambda en Java ?

Répondre:

Oui, l'utilisation d'expressions lambda facilite l'utilisation et la prise en charge d'autres API.

Q3. Quels sont les inconvénients de Java lambda ?

Répondre:

Les fonctions Java lambda ne peuvent être utilisées qu'avec des interfaces fonctionnelles.

Q4. Sur la base des règles de syntaxe qui viennent d'être présentées, laquelle des expressions suivantes n'est/ne sont PAS des expressions lambda valides ?

1. () -> {}
2. () -> geeksforgeeks
3. () -> { retourner les geeksforgeeks ;}
4. (Entier i) -> renvoie geeksforgeeks + i ;
5. (Chaîne s) -> {geeksforgeeks;}

Répondre:

4 et 5 sont des lambdas invalides, les autres sont valides. Détails:

1. Ce lambda n'a aucun paramètre et renvoie void. C'est similaire à une méthode avec un corps vide : public void run() { }.
2. Ce lambda n'a aucun paramètre et renvoie une chaîne comme expression.
3. Ce lambda n'a aucun paramètre et renvoie une chaîne (en utilisant une instruction return explicite, dans un bloc).
4. return est une instruction de flux de contrôle. Pour rendre ce lambda valide, des accolades sont requises comme suit : (Integer i) -> { return geeksforgeeks + i; }.
5. geeks pour geeks est une expression, pas une déclaration. Pour rendre ce lambda valide, vous pouvez supprimer les accolades et le point-virgule comme suit : (String s) -> geeks pour les geeks. Ou si vous préférez, vous pouvez utiliser une instruction return explicite comme suit : (String s) -> { return geeks for geeks ; }.