Expressions Java Lambda

Les expressions Lambda sont la nouvelle fonctionnalité ajoutée et introduite dans Java8. Il décrit essentiellement toutes les instances d’interfaces fonctionnelles. Son implémentation fonctionne de manière à inclure une seule fonction abstraite et à implémenter les interfaces fonctionnelles. Java 8 Lambda Expression peut créer un argument de méthode ou considérer l'intégralité du code comme des données. Il peut implémenter une fonction qui n’a pas de classe spécifique, c’est-à-dire une classe abstraite. Cette expression peut être transmise à l'objet suivant et peut être exécutée chaque fois que nécessaire. Les expressions Lambda peuvent être considérées comme des fonctions et peuvent accepter des paramètres comme les autres fonctions.

Syntaxe :

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

lambda_operator -> body

Paramètres des expressions Java Lambda

Les paramètres transmis au lambda_operator sont les suivants :

• # Paramètre zéro : Ce paramètre signifie qu'il ne peut transmettre aucun des arguments de la fonction, qui est représentée comme ci-dessous :
• () : System.out.println("Argument Zerolambda");
• # Un paramètre : Ce paramètre signifie qu'il peut transmettre n'importe lequel des arguments de la fonction, qui est représenté comme ci-dessous :
• (p): System.out.println(« Un argument : » + p);
• # Paramètre multiple : Comme son nom l'indique, ce paramètre peut être utilisé pour transmettre plus d'un paramètre à l'opérateur, et il est représenté comme ci-dessous :
• (q1, q2) : ​​System.out.println(« Arguments multiples : » + q1 + « , » + q2);

Pourquoi avons-nous besoin d'expressions Java Lambda ?

Les expressions Lambda ont vu le jour avec Java 8 et ont transformé et simplifié toute l'exécution complexe du bloc de code qui peut être transmis pour exécution. Il s'agit d'une fonctionnalité très courante utilisée par de nombreux autres langages de programmation, tout comme Java 8 ; après son introduction, la fonctionnalité précédente de Java nécessite d'abord la création d'un objet, puis de transmettre l'objet, par exemple pour créer un modèle de conception stratégique. Mais les expressions lambda ont sauvé le problème décrit ci-dessus car elles constituent une valeur ajoutée pour améliorer la mise en œuvre de l'interface fonctionnelle. Il a simplifié l'implémentation avec la fonction lambda_operator pointant vers le corps du programme possédant zéro, un et plusieurs paramètres à transmettre à la fonction. Il utilise également la fonction qui est créée et n'appartient à aucune classe définie. Il possède une très bonne fonctionnalité qui peut adopter la fonctionnalité comme argument de méthode de la fonction, qui est considérée comme des données dans leur ensemble.

Les expressions Lambda dans Java 8 sont très puissantes et très convaincantes. Il est fortement recommandé de convertir les objets liés à l'interface fonctionnelle pour sa sortie finale.

Comment fonctionnent les expressions Java Lambda ?

Il existe un modèle de travail caché dans chacune des expressions, de sorte que, en tant qu'expression Lambda, elle possède également un modèle de travail qui est représenté comme suit :

(int arg_a, String arg_b)
{System.out.println("two arguments"+ arg_a+" and "+arg_b);}

Ces deux arguments int arg_a et String arg_b constituent la liste des arguments avec zéro argument, un argument ou plus de deux arguments, c'est-à-dire plusieurs arguments. Ces arguments sous forme de liste d’arguments sont transmis au corps de l’expression lambda à l’aide du jeton fléché. Ce jeton de flèche avec sa liste d'arguments suit en permanence le corps lambda. De plus, l'expression lambda dans ce format utilise en outre une interface fonctionnelle pour sa mise en œuvre. Mais s'il s'agit de plusieurs listes d'arguments, alors il est obligatoire de fermer les crochets ou le bloc de code et alors ce type de retour de la fonction anonyme sera le même que le type de valeur qui doit renvoyer le code du bloc ou vide si qui n'est pas restitué ou qui n'a aucune valeur pour cela.

Exemples d'implémentation d'expressions Java Lambda

Vous trouverez ci-dessous des exemples d'expressions Java Lambda :

Exemple n°1

Ce programme illustre l'exécution de l'interface sans utiliser d'expressions lambda et même pas en créant une classe abstraite pour imprimer la taille du rectangle.

Code :

interface Shapes
{
public void rectangle();
}
public class WithoutLambdaExpression {
public static void main(String[] args) {
int size=15;
Shapes wd=new Shapes(){
public void rectangle()
{
System.out.println("Get the shape" +  size );
}
};
wd.rectangle();
}
}

Sortie :

Exemple n°2

Ce programme illustre la création d'une interface fonctionnelle à l'aide des expressions lambda, fournissant ainsi le résultat requis pour les formes.

Code :

interface Shapes{
public void Rectangle();
}
public class UsinglmbdaExpression {
public static void main(String[] args) {
int size=20;
Shapes r8=()->
{
System.out.println("Shapes of all sizes "+ size);
};
r8.Rectangle();
}
}

Sortie :

Example #3

This program is used to illustrate the Lambda Expression for Java 8 by not passing any parameter implemented just with the function parameter and the associated abstract classes of the implemented functional interface as shown.

Code:

interface SomethingFishy{
public String strange();
}
public class LambdaWithNoArg{
public static void main(String[] args) {
SomethingFishy k=()->{
return "Very Strange View.";
};
System.out.println(k.strange());
}
}

Output:

Example #4

This program illustrates the lambda Expression with the implementation of functional parameters, thereby passing the single parameter from the function of the interface and the lambda expression associated with it.

Code:

interface JuicyFruit{
public String juicy(String name);
}
public class SinglParamLambda
{
public static void main(String[] args)
{
JuicyFruit jf1=(name)->{
return "Kiwi, "+name;
};
System.out.println(jf1.juicy("orange"));
JuicyFruit jf2= name ->{
return "Mango, "+name;
};
System.out.println(jf2.juicy("Pineapple"));
}
}

Output:

Example #5

This program is used to illustrate the Multiple parameter lambda Expression with the functional interface of division and its values to be divided using the class’s div function.

Code:

interface Division{
int div(int p,int q);
}
public class MultiParamLambdaExpression{
public static void main(String[] args) {
Division div1=(p,q)->(p/q);
System.out.println(div1.div(20,40));
Division div2=(int p,int q)->(p/q);
System.out.println(div2.div(400,600));
}
}

Output

Note: Lambda expressions are exclusively used to implement the functional interfaces, and they can contain any type of argument such as zero, two or multiple.

Conclusion

Lambda Expression introduced with Java 8 has simplified the execution of the block of code using the array operator and operator arrow pointing to the lambda body, and then it will be used for implementing the interfaces with the abstract classes associated with each class. Thus, Lambda Expression of Java 8 has really transformed the interface interaction and the implementation of the functions and method easier with the abstract classes.

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!