Java Avance - Java : Notation Lambda

Java Avance
Java : Notation Lambda
Emmanuel ADAM
Université de Valenciennes et du Hainaut-Cambrésis
UVHC/ISTV-LAMIH
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
1 / 19
Plan
1
Java : fonctions lambda
2
Fonctions lambda et gestion de listes
Tri de collections
Fonctions de collections
3
Les flux : faciliter la sélection, l’agrégation
Extrait de collections
Flux : recherche de valeurs extrêmes
Les flux : utilisable une seule fois
Les fournisseurs de flux : utilisables plusieurs fois
Les flux : création et parcours
Les flux : conversion
Les flux : consommateur et fonctions
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
2 / 19
Java : fonctions lambda
Fonctions lambda : remplacement de classes anonymes
Interface à unique fonction
Si une interface n’a qu’une fonction, on peut se passer de la
création d’une classe anonyme.
Supposons l’interface Operation :
i n t e r f a c e Operation
{
p u b l i c double c a l c u l ( double a , double b) ;
}
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
3 / 19
Java : fonctions lambda
Fonctions lambda : remplacement de classes anonymes
Instantiation d’une interface
Classiquement on instancie en créant une classe anonyme à la
volée :
O p e r a t i o n add = new O p e r a t i o n ( ) {
p u b l i c double c a l c u l ( double a , double b)
{
return (a + b) ;
}
};
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
4 / 19
Java : fonctions lambda
Fonctions lambda : remplacement de classes anonymes
Instantiation par notation Lambda
En Lambda on écrit :
O p e r a t i o n add = ( a , b )−>{ r e t u r n ( a+b ) ; } ;
On peut également préciser le type :
O p e r a t i o n add = ( d o u b l e a , d o u b l e b )−>{ r e t u r n ( a+b ) ; } ;
Ou être plus simple :
O p e r a t i o n add = ( a , b )−>(a+b ) ;
De manière générale : (listes de variables) − > code
s’il n’y a qu’un paramètre, les parenthèses sont facultatives
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
5 / 19
Java : fonctions lambda
Fonctions lambda : remplacement de classes anonymes
Exemple d’utilisation
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
O p e r a t i o n add = ( d o u b l e a , d o u b l e b )−>{ r e t u r n ( a+b ) ; } ;
O p e r a t i o n s u b = ( a , b )−>(a−b ) ;
O p e r a t i o n mul = ( a , b )−>(a ∗b ) ;
O p e r a t i o n d i v = ( a , b )−>(a /b ) ;
Operation o = n u l l ;
i n t typeOpe = ( i n t ) ( Math . random ( ) ∗ 4 ) ;
s w i t c h ( typeOpe )
{
c a s e 0 : o = add ; b r e a k ;
c a s e 1 : o = sub ; break ;
c a s e 2 : o = mul ; b r e a k ;
case 3: o = div ; break ;
}
double x = 5 . 2 ;
double y = 2 . 5 ;
System . o u t . p r i n t l n ( ” r e s u l t a t de l ’ o p e r a t i o n ” + typeOpe+ ”
= ” + o . calcul (x , y) ) ;
}
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
6 / 19
Fonctions lambda et gestion de listes
Tri de collections
Fonctions lambda : simplifier le tri de collection
Lambda pour remplacer un Comparator
Un Comparator ne propose qu’une fonction :
int compareTo(Object o)
Lorsqu’une méthode attend un objet de type Comparator,
on peut donc passer en paramètre la fonction lambda
correspondante :
// t r i p a r o r d r e d é c r o i s s a n t
// s i ’ l i s t e ’ c o n t i e n t d e s nombres
// ( b−a ) r e t o u r n e < 0 s i
a e s t p l u s g r a n d que b ,
// donc l e t r i p l a c e r a a a v a n t b , a << b
C o l l e c t i o n s . s o r t ( l i s t e , ( a , b )−> ( b−a ) ) ;
E. ADAM
University of Valenciennes
Java Avance
...
UVHC/ISTV-LAMIH
7 / 19
Fonctions lambda et gestion de listes
Fonctions de collections
Fonctions lambdas pour les ArrayList, Vector, . . .
tris, parcours d’éléments
La fonction void sort(Comparator c) trie les éléments de
la liste
A r r a y L i s t <S t r i n g > noms = new A r r a y L i s t <S t r i n g >(
A r r a y s . a s L i s t ( ” Rebeca ” , ” P a u l a ” , ” Johanna ” ) ) ;
noms . s o r t ( ( a , b )−>a . compareTo ( b ) ) ;
La fonction void forEach(Consumer action) effectue une
action sur chaque élément de la liste
noms . f o r E a c h ( a−>System . o u t . p r i n t l n ( a ) ) ;
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
8 / 19
Fonctions lambda et gestion de listes
Fonctions de collections
Fonctions lambdas pour les ArrayList, Vector, . . .
modification d’éléments
La fonction
void replaceAll(UnaryOperator<E> operator) remplace
chaque élément de la liste par le résultat de l’opération
A r r a y L i s t <I n t e g e r > c a r r e s = new A r r a y L i s t <I n t e g e r >(
Arrays . a s L i s t (1 ,2 ,3 ,4 ,5) ) ;
c a r r e s . r e p l a c e A l l ( a−>(a ∗ a ) ) ;
La fonction boolean removeIf(Predicate condition)
retire les éléments de la liste qui répondent à la condition
// r e t i r e r l e s nombres de l a
c a r r e s . r e m o v e I f ( a−>(a <10) ) ;
E. ADAM
University of Valenciennes
liste
Java Avance
i n f é r i e u r s à 5
UVHC/ISTV-LAMIH
9 / 19
Les flux : faciliter la sélection, l’agrégation
Extrait de collections
Fonctions lambda : extraire des éléments d’une collection
Lambda pour remplacer un Filtre
Un Filtre attend une fonction de type prédicat
// c r e a t i o n d ’ une l i s t e de 10 r é e l s p r i s a l é a t o i r e m e n t
A r r a y L i s t <Double> l i s t e = new A r r a y L i s t <Double >() ;
f o r ( i n t i =0; i <10; i ++) l i s t e . add ( Math . random ( ) ∗ 1 0 ) ;
l i s t e . f o r E a c h ( e−>System . o u t . p r i n t f ( ” %.3 f ; ” , e ) ) ;
System . o u t . p r i n t l n ( ) ;
// c r é a t i o n d ’ un t a b l e a u c o n t e n a n t l e s é l é m e n t s < à 5
O b j e c t [ ] i n f = l i s t e . s t r e a m ( ) . f i l t e r ( a −> ( a <5) ) . t o A r r a y ( ) ;
f o r ( Object d : i n f )
System . o u t . p r i n t f ( ” %.3 f ; ” , d ) ;
System . o u t . p r i n t l n ( ) ;
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
10 / 19
Les flux : faciliter la sélection, l’agrégation
Extrait de collections
Filtre : utilisation de prédicat
Utilisation de prédicat
Un Filtre attend une fonction de type prédicat
Stream<T> f i l t e r ( P r e d i c a t e <? s u p e r T> p r e d i c a t e )
Un Predicat possède une seule méthode fonctionnelle :
b o o l e a n t e s t (T t )
T prend le type du flux sur lequel il est appliqué
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
11 / 19
Les flux : faciliter la sélection, l’agrégation
Flux : recherche de valeurs extrêmes
Flux : recherche de valeurs extrêmes
Recherche de minimum (et de maximum)
la fonction min (et max) applique un comparateur aux valeurs
d’un flux et retourne la valeur la plus petite, en accord avec le
comparateur
La valeur peut être nulle, le type est donc “Optionel”
O p t i o n a l <T> min ( Comparator <? s u p e r T> c o m p a r a t o r )
la fonction
boolean i s P r e s e n t ()
permet de savoir si un objet optionnel contient une valeur.
la fonction
T get ()
permet récupérer la valeur de l’objet optionnel
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
12 / 19
Les flux : faciliter la sélection, l’agrégation
Flux : recherche de valeurs extrêmes
Flux : recherche de valeurs extrêmes
Recherche de minimum
Stream<I n t e g e r > s = Stream . o f ( 1 , 8 , 4 , 5 , 6 ) ;
O p t i o n a l <I n t e g e r > m i n i = s . min ( ( a , b ) −> ( a−b ) ) ;
i f ( mini . i s P r e s e n t () )
System . o u t . p r i n t l n ( ” p l u s p e t i t
E. ADAM
University of Valenciennes
e l t = ” + mini . get () ) ;
Java Avance
UVHC/ISTV-LAMIH
13 / 19
Les flux : faciliter la sélection, l’agrégation
Les flux : utilisable une seule fois
Les flux : utilisable une seule fois
Attention : un seul parcours possible
impossibilité de lire le flux pour une fonction (exemple min) et
de le reparcourir pour une autre fonction (exemple max)
Stream<I n t e g e r > s = Stream . o f ( 1 , 8 , 4 , 5 , 6 ) ;
O p t i o n a l <I n t e g e r > m i n i = s . min ( ( a , b ) −>
O p t i o n a l <I n t e g e r > maxi = s . max ( ( a , b ) −>
( a−b ) ) ;
( a−b ) ) ;
déclenche une erreur
E x c e p t i o n i n t h r e a d ” main ” j a v a . l a n g . I l l e g a l S t a t e E x c e p t i o n :
s t r e a m h a s a l r e a d y b e e n o p e r a t e d upon o r c l o s e d
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
14 / 19
Les flux : faciliter la sélection, l’agrégation
Les fournisseurs de flux : utilisables plusieurs fois
Les fournisseurs de flux : utilisable plusieurs fois
Palier au problème de l’utilisation unique de flux
Un fournisseur de flux crée un flux à l’appel de la méthode
get()
S u p p l i e r <Stream<I n t e g e r >> f o u r n i s s e u r =
( ) −> Stream . o f ( 1 , 8 , 4 , 5 , 6 ) ;
Pour obtenir le min ET le max, on écrira :
S u p p l i e r <Stream<I n t e g e r >> f o u r n i s s e u r =
( ) −> Stream . o f ( 1 , 8 , 4 , 5 , 6 ) ;
O p t i o n a l <I n t e g e r > m i n i =
f o u r n i s s e u r . g e t ( ) . min ( ( a , b ) −> ( a−b ) ) ;
i f ( mini . i s P r e s e n t () )
System . o u t . p r i n t l n ( ” p l u s p e t i t e l t = ” + m i n i . g e t ( ) ) ;
O p t i o n a l <I n t e g e r > maxi =
f o u r n i s s e u r . g e t ( ) . max ( ( a , b ) −> ( a−b ) ) ;
i f ( maxi . i s P r e s e n t ( ) )
System . o u t . p r i n t l n ( ” p l u s g r a n d e l t = ” + maxi . g e t ( ) ) ;
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
15 / 19
Les flux : faciliter la sélection, l’agrégation
Les flux : création et parcours
Les flux : création et parcours
Création automatique
il est possible de remplir automatiquement un flux
s t a t i c <T> Stream<T> i t e r a t e (T debut , U n a r y O p e r a t o r <T>
iteration )
débute un flux avec la valeur ‘debut’ et applique la fonction
‘iteration’ sur celui-ci.
exemple, création d’un flux contenant les entiers de 0 à 9 :
Stream<I n t e g e r > s = Stream . i t e r a t e ( 0 , i −> i +1) . l i m i t
(10) ;
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
16 / 19
Les flux : faciliter la sélection, l’agrégation
Les flux : création et parcours
Les flux : création et parcours
Parcours et actions automatiques
il est possible d’appliquer une action à chaque élément de la
liste :
v o i d f o r E a c h ( Consumer <? s u p e r T> a c t i o n )
applique une fonction qui ne retourne aucune valeur à chaque
élément du flux
exemple, affichage des doubles d’un flux d’entiers
s . f o r E a c h ( e l t −> { System . o u t . p r i n t ( ” ” + e l t ∗2 + ” , ” ) ; } ) ;
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
17 / 19
Les flux : faciliter la sélection, l’agrégation
Les flux : conversion
Les flux : conversion
Conversion d’un flux en un autre flux
il est possible d’appliquer une opération à chaque élément
d’un flux et de créer un flux contenant les résultats :
<R> Stream<R> map ( F u n c t i o n <? s u p e r T , ? e x t e n d s R>
mapper )
applique la fonction mapper qui prend un élément de type T
et retourne un élément de type R
exemple, création d’une liste d’entiers de 1 à 10, et création
d’un flux contenant la racine carrée de ces entiers :
Stream<I n t e g e r > s = Stream . i t e r a t e ( 1 , i −> i +1) . l i m i t ( 1 0 ) ;
Stream<Double> s r o o t = s . map ( x −> Math . s q r t ( x ) ) ;
s r o o t . f o r E a c h ( a −> { System . o u t . p r i n t f ( ” %.3 f ; ” , a ) ; } ) ;
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
18 / 19
Les flux : faciliter la sélection, l’agrégation
Les flux : consommateur et fonctions
Les consommateurs et fonctions
Notation allégée pour consommateur et fonctions
il est possible de préciser le type des variables,
Stream<Double> s p r i m e = s . map ( ( I n t e g e r x ) −>
Math . s q r t ( x ) ) ;
s r o o t . f o r E a c h ( ( D o u b l e a ) −>
{ System . o u t . p r i n t f ( ” %.3 f ; ” , a ) ; } ) ;
il est possible pour simplifier de ne pas les indiquer
Stream<Double> s r o o t = s . map ( x −> Math . s q r t ( x ) ) ;
s r o o t . f o r E a c h ( a −> { System . o u t . p r i n t f ( ” %.3 f ; ” , a ) ; } ) ;
il est même possible de ne pas nommer la variables ! !
Stream<Double> s r o o t = s . map ( Math : : s q r t ) ;
s p r i m e . f o r E a c h ( System . o u t : : p r i n t l n ) ;
E. ADAM
University of Valenciennes
Java Avance
UVHC/ISTV-LAMIH
19 / 19