L'expression Lambda est une fonctionnalité nouvelle et importante de Java qui a été incluse dans Java SE 8. Elle fournit un moyen clair et concis de représenter une interface de méthode à l'aide d'une expression. C’est très utile dans la bibliothèque de collections. Il permet d'itérer, de filtrer et d'extraire les données de la collection.

L'expression Lambda est utilisée pour fournir l'implémentation d'une interface dotée d'une interface fonctionnelle. Cela économise beaucoup de code. Dans le cas d'une expression lambda, nous n'avons pas besoin de définir à nouveau la méthode pour fournir l'implémentation. Ici, nous écrivons simplement le code d’implémentation.

L'expression Java lambda est traitée comme une fonction, le compilateur ne crée donc pas de fichier .class.

Interface fonctionnelle

L'expression Lambda fournit l'implémentation de interface fonctionnelle . Une interface qui ne possède qu’une seule méthode abstraite est appelée interface fonctionnelle. Java fournit une annotation @ Interface fonctionnelle , qui est utilisé pour déclarer une interface comme interface fonctionnelle.

date java en chaîne

Pourquoi utiliser l'expression Lambda

1. Assurer la mise en œuvre de l'interface fonctionnelle.
2. Moins de codage.

Syntaxe des expressions Java Lambda

 (argument-list) -> {body} 

L'expression Java lambda est composée de trois composants.

1) Liste d'arguments : Il peut également être vide ou non vide.

2) Jeton flèche : Il est utilisé pour lier la liste d'arguments et le corps de l'expression.

3) Corps : Il contient des expressions et des instructions pour l'expression lambda.

Aucune syntaxe de paramètre

 () -> { //Body of no parameter lambda } 

Syntaxe à un paramètre

comment vérifier les numéros bloqués sur Android

 (p1) -> { //Body of single parameter lambda } 

Syntaxe à deux paramètres

 (p1,p2) -> { //Body of multiple parameter lambda } 

Voyons un scénario dans lequel nous n'implémentons pas l'expression Java lambda. Ici, nous implémentons une interface sans utiliser d'expression lambda.

Sans expression Lambda

 interface Drawable{ public void draw(); } public class LambdaExpressionExample { public static void main(String[] args) { int width=10; //without lambda, Drawable implementation using anonymous class Drawable d=new Drawable(){ public void draw(){System.out.println('Drawing '+width);} }; d.draw(); } } 

Sortir:

 Drawing 10 

Exemple d'expression Java Lambda

Maintenant, nous allons implémenter l'exemple ci-dessus à l'aide de l'expression Java lambda.

 @FunctionalInterface //It is optional interface Drawable{ public void draw(); } public class LambdaExpressionExample2 { public static void main(String[] args) { int width=10; //with lambda Drawable d2=()->{ System.out.println('Drawing '+width); }; d2.draw(); } } 

Sortir:

 Drawing 10 

Une expression lambda peut avoir zéro ou n’importe quel nombre d’arguments. Voyons les exemples :

Exemple d'expression Java Lambda : aucun paramètre

 interface Sayable{ public String say(); } public class LambdaExpressionExample3{ public static void main(String[] args) { Sayable s=()->{ return 'I have nothing to say.'; }; System.out.println(s.say()); } } 

Sortir:

 I have nothing to say. 

Exemple d'expression Java Lambda : paramètre unique

 interface Sayable{ public String say(String name); } public class LambdaExpressionExample4{ public static void main(String[] args) { // Lambda expression with single parameter. Sayable s1=(name)->{ return 'Hello, '+name; }; System.out.println(s1.say('Sonoo')); // You can omit function parentheses Sayable s2= name ->{ return 'Hello, '+name; }; System.out.println(s2.say('Sonoo')); } } 

Sortir:

 Hello, Sonoo Hello, Sonoo 

Exemple d'expression Java Lambda : plusieurs paramètres

 interface Addable{ int add(int a,int b); } public class LambdaExpressionExample5{ public static void main(String[] args) { // Multiple parameters in lambda expression Addable ad1=(a,b)->(a+b); System.out.println(ad1.add(10,20)); // Multiple parameters with data type in lambda expression Addable ad2=(int a,int b)->(a+b); System.out.println(ad2.add(100,200)); } } 

Sortir:

 30 300 

Exemple d'expression Java Lambda : avec ou sans mot-clé return

Dans l'expression Java lambda, s'il n'y a qu'une seule instruction, vous pouvez ou non utiliser le mot-clé return. Vous devez utiliser le mot-clé return lorsque l'expression lambda contient plusieurs instructions.

modèles de logiciels Java

 interface Addable{ int add(int a,int b); } public class LambdaExpressionExample6 { public static void main(String[] args) { // Lambda expression without return keyword. Addable ad1=(a,b)->(a+b); System.out.println(ad1.add(10,20)); // Lambda expression with return keyword. Addable ad2=(int a,int b)->{ return (a+b); }; System.out.println(ad2.add(100,200)); } } 

Sortir:

 30 300 

Exemple d'expression Java Lambda : boucle Foreach

 import java.util.*; public class LambdaExpressionExample7{ public static void main(String[] args) { List list=new ArrayList(); list.add('ankit'); list.add('mayank'); list.add('irfan'); list.add('jai'); list.forEach( (n)->System.out.println(n) ); } } 

Sortir:

 ankit mayank irfan jai 

Exemple d'expression Java Lambda : plusieurs instructions

 @FunctionalInterface interface Sayable{ String say(String message); } public class LambdaExpressionExample8{ public static void main(String[] args) { // You can pass multiple statements in lambda expression Sayable person = (message)-> { String str1 = 'I would like to say, '; String str2 = str1 + message; return str2; }; System.out.println(person.say('time is precious.')); } } 

Sortir:

 I would like to say, time is precious. 

Exemple d'expression Java Lambda : création d'un fil de discussion

Vous pouvez utiliser l'expression lambda pour exécuter le thread. Dans l'exemple suivant, nous implémentons la méthode run en utilisant l'expression lambda.

 public class LambdaExpressionExample9{ public static void main(String[] args) { //Thread Example without lambda Runnable r1=new Runnable(){ public void run(){ System.out.println('Thread1 is running...'); } }; Thread t1=new Thread(r1); t1.start(); //Thread Example with lambda Runnable r2=()->{ System.out.println('Thread2 is running...'); }; Thread t2=new Thread(r2); t2.start(); } } 

Sortir:

 Thread1 is running... Thread2 is running... 

L'expression Java lambda peut être utilisée dans le framework de collection. Il fournit un moyen efficace et concis d’itérer, de filtrer et de récupérer des données. Voici quelques exemples de lambda et de collections fournis.

gestionnaire de tâches Linux

Exemple d'expression Java Lambda : comparateur

 import java.util.ArrayList; import java.util.Collections; import java.util.List; class Product{ int id; String name; float price; public Product(int id, String name, float price) { super(); this.id = id; this.name = name; this.price = price; } } public class LambdaExpressionExample10{ public static void main(String[] args) { List list=new ArrayList(); //Adding Products list.add(new Product(1,'HP Laptop',25000f)); list.add(new Product(3,'Keyboard',300f)); list.add(new Product(2,'Dell Mouse',150f)); System.out.println('Sorting on the basis of name...'); // implementing lambda expression Collections.sort(list,(p1,p2)->{ return p1.name.compareTo(p2.name); }); for(Product p:list){ System.out.println(p.id+' '+p.name+' '+p.price); } } } 

Sortir:

 Sorting on the basis of name... 2 Dell Mouse 150.0 1 HP Laptop 25000.0 3 Keyboard 300.0 

Exemple d'expression Java Lambda : filtrer les données de collecte

 import java.util.ArrayList; import java.util.List; import java.util.stream.Stream; class Product{ int id; String name; float price; public Product(int id, String name, float price) { super(); this.id = id; this.name = name; this.price = price; } } public class LambdaExpressionExample11{ public static void main(String[] args) { List list=new ArrayList(); list.add(new Product(1,'Samsung A5',17000f)); list.add(new Product(3,'Iphone 6S',65000f)); list.add(new Product(2,'Sony Xperia',25000f)); list.add(new Product(4,'Nokia Lumia',15000f)); list.add(new Product(5,'Redmi4 ',26000f)); list.add(new Product(6,'Lenevo Vibe',19000f)); // using lambda to filter data Stream filtered_data = list.stream().filter(p -> p.price > 20000); // using lambda to iterate through collection filtered_data.forEach( product -> System.out.println(product.name+': '+product.price) ); } } 

Sortir:

 Iphone 6S: 65000.0 Sony Xperia: 25000.0 Redmi4 : 26000.0 

Exemple d'expression Java Lambda : écouteur d'événements

 import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JTextField; public class LambdaEventListenerExample { public static void main(String[] args) { JTextField tf=new JTextField(); tf.setBounds(50, 50,150,20); JButton b=new JButton('click'); b.setBounds(80,100,70,30); // lambda expression implementing here. b.addActionListener(e-> {tf.setText('hello swing');}); JFrame f=new JFrame(); f.add(tf);f.add(b); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); f.setLayout(null); f.setSize(300, 200); f.setVisible(true); } } 

Sortir: