Méthodes de programmation simultanée utilisant des expressions Lambda

Un ajout important à Java SE 8 est la fonctionnalité d'expression lambda. Utilisez des expressions pour exprimer les interfaces de méthodes de manière claire et concise. Les bibliothèques de collections sont très utiles. Les collections peuvent être itérées, filtrées et les données extraites à des fins utiles. Pour implémenter des interfaces fonctionnelles, les expressions lambda sont largement utilisées. Cela économise beaucoup de code. Les expressions Lambda nous permettent de fournir des implémentations sans redéfinir les méthodes. C'est seulement ici que le code d'implémentation est formé en écrivant du code. Le compilateur ne crée pas de fichier .class car les expressions Java lambda sont traitées comme des fonctions.

Interface fonctionnelle

@FunctionalInterface est une annotation Java qui déclare une interface comme interface fonctionnelle. L'interface fonctionnelle est une interface avec une seule méthode abstraite. Les expressions Lambda vous permettent d'implémenter cette interface fonctionnelle.

Pourquoi utiliser les expressions Lambda ?

• Il fournit la mise en œuvre d'une interface fonctionnelle.

• Il fournit moins de codage.

Syntaxe des expressions Java Lambda

(argument-list)
{
   //body
}

Il se compose de trois éléments−

• Argument-List − peut être vide ou non vide

• Arrow-Taken − Utilisé pour connecter la liste des paramètres et le corps de l'expression

• Body − Expressions et instructions contenant des expressions lambda

Syntaxe sans paramètre

()
{
   // body of no parameter lambda
}

Syntaxe à un paramètre

(p1)
{
   // body of single parameter lambda
}

Syntaxe à deux paramètres

(p1,p2)
{
   //body of multiple parameter lambda
}

Exemple : 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();  
   }  
}

Sortie

Drawing 10

Exemple : sans utiliser l'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();  
   }  
}

Sortie

Drawing 10

Exemple : aucun paramètre

interface Sayable{  
   public String say();  
}  
public class LambdaExpressionExample3{  
   public static void main(String[] args) {  
      Sayable s=()->{  
         return "Don’t settle for average.";  
      };  
      System.out.println(s.say());  
   }  
}

Sortie

Don’t settle for average

Exemple : 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("World"));  
          
      // You can omit function parentheses    
      Sayable s2= name ->{  
         return "Hello, "+name;  
      };  
      System.out.println(s2.say("World"));  
   }  
}

Sortie

Hello, World
Hello, World

Exemple : 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(20,20));  
          
      // Multiple parameters with data type in lambda expression  
      Addable ad2=(int a,int b)->(a+b);  
      System.out.println(ad2.add(200,200));  
   }  
}

Sortie

40
400

Conclusion

En utilisant des expressions, Java SE 8 fournit un ajout précieux avec la fonctionnalité d'expression lambda. Exprimer les interfaces de méthodes de manière claire et concise est devenu un jeu d’enfant. L'itération, le filtrage et l'extraction de données font partie des nombreuses utilisations pratiques offertes par les bibliothèques de collections. Les expressions Lambda ont été largement utilisées pour implémenter des interfaces fonctionnelles et peuvent réduire considérablement la quantité de code. Une excellente caractéristique des expressions lambda est la possibilité de donner une implémentation sans redéfinir la méthode de manière redondante. Dans cet espace, l’écriture donne la forme d’un code d’implémentation. Le compilateur ne crée pas de fichier .class car les fonctions sont traitées comme des expressions Java lambda.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!