26/01/2024

EXPRESSION LAMBDA

Ecole Marocaine des Sciences de l’Ingénieur

-EMSI-

Mme OUHMIDA Asmae Année universitaire 2023/2024 1

PLAN
1. L’historique des lambdas pour Java
2. La programmation fonctionnelle
3. Les expressions Lambda
4. Les interfaces fonctionnelles
5. Les méthodes de références

2
 26/01/2024

L’HISTORIQUE DES LAMBDAS POUR JAVA

Les nouveautés de Java 8
 Les collections
 Les streams
 Les interfaces fonctionnelles
 Les expressions Lambdas
C’est la JDK 8 qui implémente le projet Lambda

LA PROGRAMMATION FONCTIONNELLE
La programmation fonctionnelle est basée sur l’appel et la composition de
fonctions. Un trait important de la programmation fonctionnelle est de
considérer une fonction comme une entité de première classe (first class
citizen), c’est-à-dire qu’on peut lui appliquer les mêmes opérations que
n’importe quel autre élément du langage.
Ainsi une fonction doit posséder une identité intrinsèque lui permettant
d’être passée en paramètre d’une autre fonction ou retournée par une
autre fonction.

4
 26/01/2024

LA PROGRAMMATION FONCTIONNELLE
Ce type de représentation à plusieurs avantages.
- Il favorise le découpage du traitement en une suite de processus simples
représentés chacun par une fonction. Cela améliore la lisibilité et la
testabilité d’un programme.
- Pour le langage Java, cela offre une manière alternative d’implémenter
certains traitements en limitant l’usage des structures de contrôle
comme if ou les structures de boucle comme while et for qui sont alors
implémentées sous la forme d’appels de fonctions. L’objectif est
d’améliorer la lisibilité du code en évitant l’imbrication de blocs de
traitement et d’accolades.

LA PROGRAMMATION FONCTIONNELLE
L’introduction d’éléments de programmation fonctionnelle en Java a
été un processus complexe car la grammaire du langage ne permet
pas la déclaration de fonction.
Comme nous le verrons, les fonctions anonymes ou les références de
fonction en Java sont en fait un sucre syntaxique : il s’agit d’une
simplification d’écriture qui mobilise en arrière-plan des notions
purement objet comme l’interface fonctionnelle.

6
 26/01/2024

LES EXPRESSIONS LAMBDA

Définition:
Ce sont des méthodes anonymes (sans noms) utilisées pour implémenter une
méthode définie par une interface fonctionnelle

L’expression Lambda permet d’instancier une interface fonctionnelle

1) Simplifier la manipulation des collections en utilisant les expressions Lambdas
afin de faciliter l’écriture et la lisibilité du code
2) L’intégration de la programmation fonctionnelle

LES EXPRESSIONS LAMBDA

Syntaxe:
NomInterface nomLambdaExpression=(arguments d’entrée) -> { // traitement }

Paramètres -> Corps de l’expression Lambda

Paramètres représente les paramètres de la méthode
• Les paramètres sont indiqués entre parenthèses (x,y,z)
• S’il n’y a pas de paramètres, il suffit de mettre des parenthèses vides ()

Corps de l’expression Lambda représente le code de la méthode

• Si le corps de la méthode ne fait qu’une ligne, nous n’avons pas besoin
d’utiliser d’accolades. L’expression indiquée sera retournée par l’expression
Lambda.
• Si le corps fait plusieurs lignes, nous nous pouvons utiliser des accolades
comme dans une méthode classique. Il faut alors utiliser le mot clé return
pour indiquer la valeur retournée par l’expression Lambda.
8
 26/01/2024

LES EXPRESSIONS LAMBDA

 Exemple:
public interface OperationMath{
public int operation (int a, int b);
} Signature de la
méthode

OperationMath addition = (int a, int b) -> a+b; //avec le type d’argument d’entrée
OperationMath produit = (a, b) -> a*b; //sans déclaration des types
OperationMath soustraction = (int a, int b) -> {return a – b;}; //avec typage et return

Nom de Nom de Lambda Arguments Corps du Lambda

l’interface expression d’entrée expression

LES EXPRESSIONS LAMBDA

 Exemple:
public interface OperationMath{
public int operation (int a, int b);
}
public class A{
public int apply (int a, int b, OperationMath op){ return [Link] (a,b);}
}
public static void main (String [] args) {
A pf = new A();
OperationMath addition = (int a, int b) -> a+b;
OperationMath produit = (a, b) -> a*b;
int s= [Link] (a, b, addition); //utilisation du lambda expression addition
int p= [Link] (a, b, produit); //utilisation du lambda expression produit
}
10
 26/01/2024

LES EXPRESSIONS LAMBDA

Exemples:

double getPi() { return 3.1415; }

L'expression lambda équivalente pour la méthode ci-dessus est:

() -> 3.1415

11

LES EXPRESSIONS LAMBDA

Exercices:

1) Écrire un programme Java pour mettre en œuvre une expression lambda

permettant de filtrer les nombres pairs et impairs d'une liste d'entiers.

2) Écrire un programme Java pour mettre en œuvre une expression lambda

permettant de vérifier si une liste de chaînes de caractères contient un mot
spécifique.

12
 26/01/2024

LES EXPRESSIONS LAMBDA

Correction:
import [Link];
import [Link];
import [Link];
public class Main {
public static void main(String[] args) {
// Create a list of integers
List nums = [Link](11, 23, 98, 34, 15, 32, 42, 80, 99, 100);
// Print the original numbers
[Link]("Original numbers:");
for (int n : nums) { [Link](n+ " "); }
// Filter out even numbers using lambda expression
List evenNumbers = [Link]() .filter(n -> n % 2 == 0) .collect([Link]());
// Print the even numbers
[Link]("\nEven numbers:");
for (int num : evenNumbers) { [Link](num + " "); }
// Filter out odd numbers using lambda expression
List oddNumbers = [Link]() .filter(num -> num % 2 != 0)
.collect([Link]());
// Print the odd numbers [Link]("\nOdd numbers:"); for (int num : oddNumbers)
{ [Link](num + " "); } } }

13

LES EXPRESSIONS LAMBDA

import [Link]; import [Link]; import [Link];
public class Main {
public static void main(String[] args) {
// Create a list of strings
List < String > colors = [Link]("Red", "Green", "Blue", "Orange", "Black");
// Specify the word to search for
String searchColor = "Orange";
// Check if the list contains the specified color using a lambda expression
Predicate < String > containsWord = word -> [Link](searchColor);
boolean flag = [Link]().anyMatch(containsWord);
// Print the result
[Link]("Is the word " + searchColor + " present in the list? " + flag);
// Specify the word to search for
String searchColor1 = "White";
// Check if the list contains the specified color using a lambda expression
Predicate < String > containsWord1 = word -> [Link](searchColor1);
flag = [Link]().anyMatch(containsWord1);
// Print the result
[Link]("\nIs the word " + searchColor1 + " present in the list? " + flag); }
}
14
 26/01/2024

LES INTERFACES FONCTIONNELLES

Définition:
 Appelée auparavant « Single abstract méthode », c’est interface qui contient
une seule méthode abstraite
 L’interface fonctionnelle permet de passer en paramètre une méthode
comme:
 Une référence vers une méthode statique
 Une référence vers une méthode d’une instance
 Une référence vers un constructeur
 Une expression Lambda

Déclaration:
public interface Nom Interface{
public valeurRetour nomMethode (Paramètres); }
Exemple:
public interface OperationMath{
public int operation (int a, int b); }
15

LES INTERFACES FONCTIONNELLES

Interfaces fonctionnelles standard disponibles en java:

 Java 8 introduit l’API des interfaces fonctionnelles dans le package

[Link]
 Java contient un ensemble d’interfaces fonctionnelles conçues pour faire
face aux cas d’utilisation les plus courants, ce qui évite de créer vos propres
interfaces fonctionnelles pour chaque petit cas d’utilisation.
 Function
 Predicate
 UnaryOperator
 BinaryOperatorInterface name Arguments Returns Example
 Supplier
 Consumer

16
 26/01/2024

LES INTERFACES FONCTIONNELLES

Nom de l’interface Paramètre Type de retour

Predicate<T> T boolean
Consumer<T> T void
Function<T,R> T R
Supplier<T> None T
UnaryOperator<T> T T
BinaryOperator<T> (T, T) T

17

LES INTERFACES FONCTIONNELLES : FUNCTION

L’interface Java Function ([Link]) est l’une des interfaces
fonctionnelles les plus importantes de Java.
C’est une fonction (méthode) qui prend un seul paramètre et renvoie une seule
valeur. Voici à quoi ressemble la définition de l’interface Function :
public interface Function<T,R> {
public <R> apply(T parameter); }

L’interface Function contient quelques méthodes supplémentaires, mais elles ont

une implémentation par défaut, vous n’avez pas besoin d’implémenter ces
méthodes.
La seule méthode que vous devez implémenter pour mettre en œuvre
l’interface Function est la méthode apply().

18
 26/01/2024

LES INTERFACES FONCTIONNELLES : FUNCTION

Voici un exemple d’implémentation de la fonction :
public class AjouterTrois implements Function<Long, Long> {
Cette implémentation de
@Override
Function implémente la
public Long apply(Long unLong) {
méthode apply() qui prend
return unLong + 3; un Long comme paramètre,
} et retourne un Long.
}
Voici un exemple d’utilisation de la classe AjouterTrois
Function<Long,
ci-dessus : Long> ajouteur = new AjouterTrois (); // créer une nouvelle instance et l’affecter à une
variable de type Function
Long result = [Link]((long) 4); //appeler la méthode apply
[Link]("result = " + result); // afficher le résultat
19

LES INTERFACES FONCTIONNELLES : FUNCTION

Vous pouvez également implémenter l’interface Function en utilisant
une expression lambda Java. Voici à quoi cela ressemble :

Function<Long, Long> ajouteur = (value) -> value + 3;

Long resultaLambda = [Link]((long) 8);
[Link]("resultLambda = " + resultLambda);

L’implémentation de l’interface Function

est intégrée au niveau de la déclaration
de la variable resultaLambda, plutôt que
dans une classe séparée.

20
 26/01/2024

LES INTERFACES FONCTIONNELLES : PREDICATE

L’interface Java Predicate ([Link]) est une fonction
simple qui prend une seule valeur comme paramètre, et retourne un
booléen.
Voici à quoi ressemble la définition de l’interface fonctionnelle Predicate :

public interface Predicate {

boolean test(T t);
}

L’interface Predicate contient plus de méthodes que la méthode test(),

mais le reste des méthodes sont des méthodes par défaut ou statiques que
vous n’avez pas à implémenter.

21

LES INTERFACES FONCTIONNELLES : PREDICATE

Vous pouvez implémenter l’interface Predicate en utilisant une classe, comme
ceci :
public class VerifierLeNull implements Predicate { Cette implémentation de
@Override Predicate implémente la
public boolean test(Object o) { méthode test() qui prend
return o != null; un Object comme
} paramètre, et retourne
} un boolean.

En utilisant une expression Lambda: Cette implémentation lambda de

l’interface Predicate fait la même
Predicate predicate = (value) -> value != null; chose que l’implémentation ci-
dessus..

22
 26/01/2024

LES INTERFACES FONCTIONNELLES : UNARYOPERATOR

L’interface Java UnaryOperator est une interface fonctionnelle qui représente
une opération qui prend un seul paramètre et renvoie un paramètre du même
type. Voici un exemple d’implémentation de Java UnaryOperator :
UnaryOperator<Personne> unaryOperator =
(person) -> { [Link] = "nouveau nom";
return personne;
};
L’interface UnaryOperator peut être utilisée pour représenter une opération
qui prend un objet spécifique comme paramètre, modifie cet objet et le
renvoie à nouveau – éventuellement dans le cadre d’une chaîne de
traitement de flux fonctionnel.
23

LES INTERFACES FONCTIONNELLES : BINARYOPERATOR

L’interface Java BinaryOperator est une interface fonctionnelle qui
représente une opération qui prend deux paramètres et renvoie une seule
valeur. Les deux paramètres et le type de retour doivent être identique.

L’interface Java BinaryOperator est utile pour mettre en œuvre des fonctions
qui additionnent, soustraient, divisent, multiplient, etc. deux éléments du
même type, et qui renvoient un troisième élément du même type.

Voici un exemple d’implémentation de l’interface BinaryOperator :

BinaryOperator<MaValeur> binaryOperator =
valuer1, valuer2) -> { [Link](valuer2);
return valuer1; };
24
 26/01/2024

LES INTERFACES FONCTIONNELLES : SUPPLIER

L’interface Java Supplier est une interface fonctionnelle qui représente une
fonction qui fournit une valeur X. L’interface Supplier peut également être
considérée comme une interface Factory.
Voici un exemple d’implémentation de l’interface Java Supplier :

Supplier<Integer> supplier = () -> new Integer((int) ([Link]() * 1000D));

Cette implémentation de Java Supplier renvoie une nouvelle

instance d’Integer avec une valeur aléatoire entre 0 et 1000.

25

LES INTERFACES FONCTIONNELLES : CONSUMER

L’interface Java Consumer est une interface fonctionnelle qui représente
une fonction qui consomme une valeur sans en retouner une autre valeur.
Cette interface peut être utiliser pour l’impression d’une valeur, ou l’écriture
dans un fichier, ou sur le réseau, etc.
Voici un exemple d’implémentation de l’interface Java Consumer :

Consumer<Integer> consumer = (value) -> [Link](value);

Cette implémentation Java Consumer imprime la valeur qui lui est passée
en paramètre dans [Link].

26
 26/01/2024

MÉTHODES DE RÉFÉRENCE
– Lambda expression permet de créer des méthodes anonymes. Dans
des cas spécifiques, lambda expression utilise des méthodes existantes.
– Java 8 a introduit les méthodes de référence pour répondre à ce
besoin.
– Une méthode de référence vise à associer une « instance » d’une
interface fonctionnelle à un code existant.
– Elle favorise l’exploitation du code existant et aussi sa lisibilité.

27

MÉTHODES DE RÉFÉRENCE: CAS POSSIBLES

Quatre cas sont possibles:
 Référence vers une méthode statique
 Référence vers un constructeur
 Référence vers une méthode d’instance
 Référence vers une méthode d’un objet arbitraire de type particulier
La syntaxe d’une méthode de référence consiste à utiliser le nom de la
classe ou l’instance de la classe, suivi de l’opérateur « :: » et du nom de la
méthode à référencer

28
 26/01/2024

RÉFÉRENCE VERS UNE MÉTHODE D’INSTANCE

interface Distancier { public double distance (Mesure m1, Mesure m2);}
class Mesure { Méthode d’interface
private double x;
public Mesure (double x) {this.x=x;}
public double distance1 (Mesure m) { return this.x-m.x; }
public double distance2 (Mesure m) { return [Link](this.x-m.x);}
} Méthode d’instance
public static void main (String [] args){
Mesure m1= new Mesure(12), m2=new Mesure(25);
Distancier d1= Mesure::distance1; //référence vers la méthode distance1
Distancier d2= Mesure::distance2; //référence vers la méthode distance2
[Link] (" distance1 entre m1 et m2= " +[Link](m1,m2));
[Link] (" distance2 entre m1 etm2= " +[Link](m1,m2));
} Références vers des méthodes d’instance

29

RÉFÉRENCE VERS UN CONSTRUCTEUR

interface Fabrique<T> { public T getInstance (double x);}
Méthode d’interface

class Mesure {
private double x;
public Mesure (double x) {this.x=x;}
public String toString () { return " Mesure [ x=" + x + "]"; }
} Constructeur

public static void main (String [] args){

Fabrique <Mesure> fin= Mesure::new;
Mesure m= [Link] (17);
[Link] (" dm= " +[Link]()); Références vers un constructeur
}

30
 26/01/2024

RÉFÉRENCE VERS UNE MÉTHODE STATIQUE

interface ICompteur{ public T getCompteur ();}
Méthode d’interface

class Mesure {
private int compteur=0;
public Mesure (double x) {this.x=x; compteur++; }
public static int getNbInstance() { return compteur; }
} Constructeur

public static void main (String [] args){

Icompteur compt= Mesure::getNbInstance ;
Mesure m1= new Mesure(3), m2=new Mesure(7);
[Link] (" nombre d’instances = " +[Link]());
} Référence vers une méthode statique

31