Les expressions lambda en action

Quelques exemples simples qui mettent en pratique les concepts de base des expressions lambda :

Exemple 1 - Comparaison d'implémentation sans et avec lambda

Pas d'utilisation de lambda :

Interface MyValueSemLambda1 {
double getValue(); // Méthode abstraite
>
la classe MyValueImpl implémente MyValueSemLambda1{
valeur double privée ;
// Constructeur pour initialiser l'attribut value
public MyValueImpl (valeur double) {
this.value = valeur;
>
// Implémentation de la méthode getValue
@Override
public double getValue() {
renvoie this.value;
>
>
classe publique MyValueSemLambda {
public static void main (String[] args) {
MyValueSemLambda1 myVal = new MyValueImpl(98.6); // Attribution d'une valeur à l'attribut
System.out.println("Valeur : " maVal.getValue()); // Imprime 98,6
>
>

Utilisation de lambda :

Interface MyValueCompare {
double getValue();
>
classe publique MyValueComparacao {
public static void main (String[] args) {
// Expression Lambda sans attribut, mais renvoyant une valeur
MyValueCompares myVal = () -> 98,6;
System.out.println("Valeur : " maVal.getValue()); // Imprime 98,6
>
>

Exemple 2 - LambdaDemo

// Une interface fonctionnelle.
interface MaValeur {
double getValue();
>
// Une autre interface fonctionnelle.
interface MyParamValue {
double getValue(double v);
>
classe LambdaDemo {
public static void main(String args[])
{
MaValeur maVal; // déclare une référence d'interface
// Ici, l'expression lambda est simplement une expression constante.
// Lorsqu'elle est assignée à myVal, l'instance
est construite // d'une classe où l'expression lambda implémente le
// Méthode getValue() de MyValue.
maVal = () -> 98,6 ; Une simple expression lambda
// Appelle getValue(), qui est fourni par
// expression lambda précédemment attribuée.
System.out.println("Une valeur constante : " myVal.getValue());
// Créez maintenant une expression lambda paramétrée et attribuez-la
// pour une référence MyParamValue. Cette expression lambda revient
// l'inverse de son argument.
MyParamValue myPval = (n) -> 1,0/n ; Une expression lambda
qui a un paramètre
// Appelez getValue() via la référence myPval.
System.out.println("L'inverse de 4 est " myPval.getValue(4.0));
System.out.println("L'inverse de 8 est " myPval.getValue(8.0));
// Une expression lambda doit être compatible avec la méthode définie
// via l'interface fonctionnelle. Par conséquent, ces instructions ne fonctionneront pas :
// maVal = () -> "trois"; // Erreur! La chaîne n'est pas compatible avec le double !
// monPval = () -> Math.random(); // Erreur! Le paramètre est obligatoire !
>
>

Sortie :
Une valeur constante : 98,6
L'inverse de 4 est 0,25
L'inverse de 8 est 0,125

• L'expression lambda doit être compatible avec la méthode abstraite que vous implémentez.

Exemple d'incompatibilités :

• Une valeur String ne peut pas être utilisée si le type de retour attendu est double.

• Une méthode qui nécessite un paramètre ne peut pas être utilisée sans le fournir.

• Une interface fonctionnelle peut être utilisée avec n'importe quelle expression lambda compatible.

Exemple 3 - Test numérique

Test de divisibilité : Vérifie si le premier nombre est divisible par le second.
Comparaison des tailles : Détermine si le premier nombre est plus petit que le second.
Comparaison des valeurs absolues : Renvoie vrai si les valeurs absolues des deux nombres sont égales.

• Dans main(), trois tests différents sont créés à l'aide d'expressions lambda.

// Interface fonctionnelle qui prend deux paramètres int et
// renvoie un résultat booléen.
interface NumericTest {
test booléen(int n, int m);
>
classe LambdaDemo2 {
public static void main(String args[])
{
// Cette expression lambda détermine si un nombre
// est un facteur d'un autre.
NumericTest isFactor = (n, d) -> (n % d) == 0;
si(isFactor.test(10, 2))
System.out.println("2 est un facteur de 10");
si(!isFactor.test(10, 3))
System.out.println("3 n'est pas un facteur 10");
System.out.println();
// Cette expression lambda renvoie vrai si le
// le premier argument est plus petit que le second.
NumericTest lessThan = (n, m) -> (n si(moinsThan.test(2, 10))
System.out.println("2 est inférieur à 10");
if(!lessThan.test(10, 2))
System.out.println("10 n'est pas inférieur à 2");
System.out.println();
// Cette expression lambda renvoie vrai si vous
// les valeurs absolues des arguments sont égales.
NumericTest absEqual = (n, m) -> (n < 0 ? -n : n) == (m < 0 ? -m : m);
si(absEqual.test(4, -4))
System.out.println("Les valeurs absolues de 4 et -4 sont égales.");
if(!lessThan.test(4, -5))
System.out.println("Les valeurs absolues de 4 et -5 ne sont pas égales.");
System.out.println();
>
>

Sortie :
2 est un facteur de 10
3 n'est pas un facteur 10
2 est inférieur à 10
10 n'est pas inférieur à 2
Les valeurs absolues de 4 et -4 sont égales.
Les valeurs absolues de 4 et -5 ne sont pas égales.

• Les expressions lambda compatibles peuvent être utilisées avec la même interface fonctionnelle.

• La même variable de référence peut être réutilisée pour différentes expressions lambda.

• La réutilisation des variables facilite la lecture et économise les ressources dans le code.

• Dans l'exemple, la même interface est utilisée pour différentes implémentations :

Test numérique monTest ;
monTest = (n, d) -> (n % d) == 0 ; //implémentation 1
si(monTest.test(10, 2))
System.out.println("2 est un facteur de 10");
// ...
monTest = (n, m) -> (n &Lt ; m) ; //implémentation 2
si(monTest.test(2, 10))
System.out.println("2 est inférieur à 10");
//...
monTest = (n, m) -> (n < 0 ? -n : n) == (m < 0 ? -m : m); //implémentation 3
si(monTest.test(4, -4))
System.out.println("Les valeurs absolues de 4 et -4 sont égales.");
// ...

Clarté avec les variables de référence

L'utilisation de différentes variables de référence (par exemple isFactor, lessThan, absEqual) vous aide à identifier clairement quelle expression lambda représente chaque variable.

Spécification de plusieurs paramètres

Plusieurs paramètres dans les expressions lambda sont séparés par des virgules dans une liste entre parenthèses sur le côté gauche de l'opérateur lambda.
Exemple : (n, d) -> (n % d) == 0.

Utilisation de différents types dans les expressions lambda

Il n'y a aucune restriction sur le type de paramètres ou de retour dans les méthodes abstraites des interfaces fonctionnelles.
Les types de données non primitifs comme String peuvent être utilisés dans les expressions lambda.

Exemple de test avec des chaînes

Une interface fonctionnelle peut être utilisée pour tester des conditions spécifiques liées aux chaînes, par exemple vérifier si une chaîne est contenue dans une autre.

// Une interface fonctionnelle qui teste deux chaînes.
interface StringTest {
test booléen (String aStr, String bStr);
>
classe LambdaDemo3 {
public static void main(String args[])
{
// Cette expression lambda détermine si une chaîne fait
// partie d'un autre.
StringTest isIn = (a, b) -> a.indexOf(b) != -1;
String str = "Ceci est un test";
System.out.println("Chaîne de test : " str);
if(isIn.test(str, "est un"))
System.out.println("'est un' trouvé.");
d'autre
System.out.println("'est un' introuvable.");
if(isIn.test(str, "xyz"))
System.out.println("'xyz' Trouvé");
d'autre
System.out.println("'xyz' introuvable");
>
>

Sortie :
Chaîne de test : Ceci est un test
'est un' trouvé.
'xyz' introuvable

Interface fonctionnelle StringTest

Définit une méthode abstraite de test (String aStr, String bStr) qui renvoie une valeur booléenne.

Implémentation avec expression lambda

L'expression lambda (a, b) -> a.indexOf(b) != -1 vérifie si une chaîne (b) est contenue dans une autre (a).

Tapez l'inférence dans les paramètres

Les paramètres a et b sont supposés être de type String, permettant l'utilisation de méthodes de la classe String, telles que indexOf.

Le programme teste la chaîne "Ceci est un test" pour voir si elle contient les sous-chaînes "is a" et "xyz", imprimant les résultats en conséquence.

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!