Java 8-streams-collectors-patterns

Java 8 Streams & Collectors
Patterns, performance, parallélisation
@JosePaumard

@JosePaumard
Stream
Collectors

@JosePaumard#Stream8
Du code et des slides
1ère partie : des slides
- Stream
- Opérations
- État
- Réduction
- Collector
2ème partie : code + slides
- Houston
- Shakespeare
- Actors

Questions ?
#Stream8
@JosePaumard

Qu’est-ce qu’un Stream ?

Techniquement : une interface paramétrée
public interface Stream<T> extends BaseStream<T, Stream<T>> {
// ...
}

Techniquement : une interface paramétrée
Pratiquement : un nouveau concept
public interface Stream<T> extends BaseStream<T, Stream<T>> {
// ...
}

À quoi un Stream sert-il ?

À quoi un Stream sert-il ?
Réponse : à traiter efficacement les grands volumes de
données, et aussi les petits

Que signifie efficacement ?

Deux choses :

Deux choses :
1) en parallèle, pour exploiter le multicœur

Deux choses :
1) en parallèle, pour exploiter le multicœur
2) en pipeline, pour éviter les intermédiaires de calcul

Pourquoi une collection ne peut-elle constituer un Stream ?

Il y a des arguments pour qu’une collection soit un Stream !

1) mes données sont dans des collections (ou tables de
hachage)

1) mes données sont dans des collections (ou tables de
hachage)
2) on connaît bien l’API Collection…

Deux raisons :
1) ça permet d’avoir les mains libres

Deux raisons :
1) ça permet d’avoir les mains libres
2) ça permet de ne pas polluer l’API Collection avec ces
nouveaux concepts

Donc : qu’est-ce qu’un Stream ?
Réponses :

Réponses :
1) un objet qui sert à définir des opérations

Réponses :
2) qui ne possède pas les données qu’il traite (source)

Réponses :
3) qui s’interdit de modifier les données qu’il traite

Réponses :
4) qui traite les données en « une passe »

Réponses :
4) qui traite les données en « une passe »
5) qui est optimisé du point de vue algorithmique et qui est
capable de calculer en parallèle

Comment construit-on un Stream ?
Plein de patterns !

Comment construit-on un Stream ?
Plein de patterns !
Choisissons-en un :
List<Person> persons = ... ;
Stream<Person> stream = persons.stream() ;

Opérations sur un Stream
Première opération : forEach()
… affiche chaque personne sur la console
stream.forEach(p -> System.out.println(p)) ;

… affiche chaque personne sur la console
stream.forEach(System.out::println) ;

Method reference :
stream.forEach(System.out::println) ;
o -> System.out.println(o) ≡ System.out::println

Opération forEach()
forEach() : prend un Consumer<T> en paramètre
@FunctionalInterface
public interface Consumer<T> {
void accept(T t) ;
}

Opération forEach()
forEach() : prend un Consumer<T> en paramètre
Interface fonctionnelle ?
void accept(T t) ;
}

Sauf qu’en fait…
Consumer est un peu plus complexe que ça :
void accept(T t) ;
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}

Sauf qu’en fait…
Consumer est un peu plus complexe que ça :
Méthode par défaut ?
void accept(T t) ;
}
}

Interface fonctionnelle
= une interface qui ne possède qu’une seule méthode

« peut » être annotée par @FunctionalInterface

Les méthodes de Object ne « comptent » pas

Les méthodes de Object ne « comptent » pas
Peut comporter des méthodes « par défaut »

Méthodes par défaut
Nouveauté Java 8 !

Nouveauté Java 8 !
Intégrée pour permettre de faire évoluer des vieilles
interfaces

Nouveauté Java 8 !
Intégrée pour permettre de faire évoluer des vieilles
interfaces
Cas de Collection : on a ajouté stream()

Quid de l’héritage multiple ?

On a déjà l’héritage multiple en Java !
public final class String
implements Serializable, Comparable<String>, CharSequence {
// ...
}

On a déjà l’héritage multiple en Java !
On a l’héritage multiple de type
public final class String
implements Serializable, Comparable<String>, CharSequence {
// ...
}

Java 8 amène l’héritage multiple d’implémentation

Ce que l’on n’a pas, c’est l’héritage multiple d’état

Ce que l’on n’a pas, c’est l’héritage multiple d’état
et d’ailleurs… on n’en veut pas !

Conflits ?

Conflits ?
oui…

public class A
implements B, C {
}
public interface C {
default String a() {...}
}
public interface B {
}

Conflit : erreur de compilation !
public class A
implements B, C {
}
}
}

Pour lever l’erreur : deux solutions
public class A
implements B, C {
}
}
}

1) La classe gagne !
public class A
implements B, C {
public String a() {...}
}
}
}

public class A
implements B, C {
public String a() { B.super.a() ; }
}
}
}

2) Le plus spécifique gagne !
public class A
implements B, C {
}
public interface B extends C {
}
}

Conflits ?
oui…
2 règles pour les gérer :

Conflits ?
oui…

Conflits ?
oui…
2) Le plus spécifique gagne !

Retour sur Consumer
void accept(T t) ;
}
}

Retour sur Consumer
List<String> liste = new ArrayList<>() ;
Consumer<String> c1 = s -> liste.add(s) ;
Consumer<String> c2 = s -> System.out.println(s) ;

Retour sur Consumer
Consumer<String> c1 = liste::add ;
Consumer<String> c2 = System.out::println ;

Retour sur Consumer
Consumer<String> c2 = System.out::println ;
Consumer<String> c3 = c1.andThen(c2) ; // et on pourrait continuer

Retour sur Consumer
Attention à la concurrence !
List<String> resultat = new ArrayList<>() ;
persons.stream()
.forEach(c1) ; // concurrence ?

Retour sur Consumer
persons.stream().parallel()
.forEach(c1) ; // concurrence ?

Retour sur Consumer
persons.stream()
.forEach(c1) ; // concurrence ? Baaad pattern !

Retour sur Consumer
Problème : forEach() ne retourne rien
Consumer<String> c2 = System.out::println
persons.stream()
.forEach(c1.andThen(c2)) ;

Retour sur Consumer
Peek à la rescousse !
persons.stream()
.peek(System.out::println)
.filter(person -> person.getAge() > 20)
.peek(resultat::add) ; // Baaad pattern !

Retour sur Stream
Donc on a :
- une méthode forEach(Consumer)
- une méthode peek(Consumer)

Retour sur Stream
3ème méthode : filter(Predicate)

Méthode filter()
List<Person> liste = ... ;
Stream<Person> stream = liste.stream() ;
Stream<Person> filtered =
stream.filter(person -> person.getAge() > 20) ;

Méthode filter()
Predicate<Person> p = person -> person.getAge() > 20 ;

Interface Predicate
public interface Predicate<T> {
boolean test(T t) ;
}

Interface Predicate
En fait …
boolean test(T t) ;
default Predicate<T> and(Predicate<? super T> other) { ... }
default Predicate<T> or(Predicate<? super T> other) { ... }
default Predicate<T> negate() { ... }
}

Interface Predicate
default Predicate<T> and(Predicate<? super T> other) {
return t -> test(t) && other.test(t) ;
}
default Predicate<T> or(Predicate<? super T> other) {
return t -> test(t) || other.test(t) ;
}
default Predicate<T> negate() {
return t -> !test(t) ;
}

Interface Predicate : patterns
Predicate<Integer> p1 = i -> i > 20 ;
Predicate<Integer> p2 = i -> i < 30 ;
Predicate<Integer> p3 = i -> i == 0 ;

Predicate<Integer> p = p1.and(p2).or(p3) ; // (p1 AND p2) OR p3

Predicate<Integer> p = p1.and(p2).or(p3) ; // (p1 AND p2) OR p3
Predicate<Integer> p = p3.or(p1).and(p2) ; // (p3 OR p1) AND p2

Interface Predicate
En fait (bis) …
boolean test(T t) ;
// méthodes par défaut
static <T> Predicate<T> isEqual(Object o) { ... }
}

Interface Predicate
static <T> Predicate<T> isEqual(Object o) {
return t -> o.equals(t) ;
}

Interface Predicate
En fait :
}
return (null == o)
? obj -> Objects.isNull(obj)
: t -> o.equals(t) ;
}

Interface Predicate
En fait :
}
return (null == o)
? Objects::isNull
: o::equals ;
}

Predicate<String> p = Predicate.isEqual("deux") ;

Predicate<String> p = Predicate.isEqual("deux") ;
Stream<String> stream1 = Stream.of("un", "deux", "trois") ;
Stream<String> stream2 = stream1.filter(p) ;

Interface Predicate : remarque
Dans ce code :
Les deux streams stream et filtered sont différents
La méthode filter() retourne un nouvel objet

Question : qu’est-ce que j’ai dans cet objet ?

Réponse : mes données filtrées

vraiment ?

vraiment ?
« un stream ne porte pas de données »…

Réponse : rien !

Question 2 :
que se passe-t-il lors de l’exécution de ce code ?

Question 2 :
Réponse : rien !

Question 2 :
Réponse : rien !
Cet appel est une déclaration : aucun traitement n’est fait !

L’appel à filter() est un appel lazy
D’une façon générale :
un appel qui retourne un Stream est lazy

L’appel à filter() est un appel lazy
Autre façon de le dire :
une opération qui retourne un Stream est
une opération intermédiaire

Appels intermédiaires
Le fait de choisir qu’un stream ne porte pas ses données
crée la notion d’opération intermédiaire

Appels intermédiaires
Le fait de choisir qu’un stream ne porte pas ses données
crée la notion d’opération intermédiaire
On doit bien avoir des opérations terminales quelque part…

Retour sur Consumer (bis)
Que se passe-t-il dans ce code ?
persons.stream()

Rien !
persons.stream()

1) rien ne s’affiche !
2) resultat reste vide !
persons.stream()

Retour sur Stream
Donc on a :
- une méthode filter(Predicate)

Continuons
Opération de mapping

Continuons
Stream<String> names =
stream.map(person -> person.getNom()) ;

Continuons
Retourne un stream (différent du stream original)
Donc opération intermédiaire
Stream<String> names =
stream.map(person -> person.getNom()) ;

Mapper : interface Function
public interface Function<T, R> {
R apply(T t) ;
}

En fait
R apply(T t) ;
default <V> Function<V, R> compose(Function<V, T> before) ;
default <V> Function<T, V> andThen(Function<R, V> after) ;
}

En fait
Gare aux génériques !
R apply(T t) ;
default <V> Function<V, R> compose(Function<V, T> before) ;
default <V> Function<T, V> andThen(Function<R, V> after) ;
}

En fait
R apply(T t) ;
default <V> Function<V, R> compose(
Function<? super V, ? extends T> before) ;
default <V> Function<T, V> andThen(
Function<? super R, ? extends V> after) ;
}

En fait
R apply(T t) ;
// méthodes par défaut
static <T> Function<T, T> identity() {
return t -> t ;
}
}

Retour sur Stream
Donc on a :
- une méthode filter(Predicate)
- une méthode map(Function)

Continuons
Opération flatMap

Méthode flatMap()
flatMap() = mettre à plat
Signature :
<R> Stream<R> flatMap(Function<T, Stream<R>> mapper) ;

Méthode flatMap()
Signature :
<R> Stream<R> map(Function<T, R> mapper) ;

Méthode flatMap()
Signature :
La fonction mapper transforme
des éléments T
en éléments Stream<R>
... flatMap(Function<T, Stream<R>> mapper) ;

Méthode flatMap()
Signature :
S’il s’agissait d’un mapping classique
flatMap() retournerait Stream<Stream<R>>

Méthode flatMap()
Signature :
S’il s’agissait d’un mapping classique
flatMap() retournerait Stream<Stream<R>>
Donc un « stream de streams »

Méthode flatMap()
Signature :
Mais il s’agit d’un flatMap !

Méthode flatMap()
Signature :
Et le flatMap met le Stream<Stream> « à plat »

Méthode flatMap()
Signature :
Retourne un stream, donc opération intermédiaire

Bilan sur Stream
On a 3 types de méthodes :
- forEach() : consomme
- peek() : regarde et passe à un consommateur
- filter() : filtre
- map() : mappe = transforme
- flatMap() : mappe et met à plat

Bilan sur Stream
On a 3 types de méthodes :
- forEach() : consomme
- peek() : regarde et passe à un consommateur
- filter() : filtre
- map() : mappe = transforme
- flatMap() : mappe et met à plat
Réduction ?

Réduction
Méthode de réduction :
List<Integer> ages = ... ;
Stream<Integer> stream = ages.stream() ;
Integer somme =
stream.reduce(0, (age1, age2) -> age1 + age2) ;

Réduction
Expression lambda sur deux éléments : applicable à tout un
stream
Integer somme =

Réduction
Doit être associative…
Reducer r1 = (i1, i2) -> i1 + i2 ; // ok

Réduction
Reducer r1 = (i1, i2) -> i1 + i2 ; // ok
Reducer r2 = (i1, i2) -> i1*i1 + i2*i2 ; // oooops...

Réduction
Reducer r1 = (i1, i2) -> i1 + i2 ; // ok
Reducer r2 = (i1, i2) -> i1*i1 + i2*i2 ; // oooops...
Reducer r3 = (i1, i2) -> (i1 + i2)/2 ; // re-oooops...

Réduction
0 : valeur par défaut pour le cas où la source est vide
Integer somme =

Réduction
Autre méthode de réduction :
Quel type de retour pour max ? (ou min…)
... max =
stream.max(Comparator.naturalOrder()) ;

Type de retour pour la réduction
Quel est la valeur par défaut du max ?
1) la valeur par défaut est la réduction de l’ensemble vide
2) mais c’est aussi l’élément neutre de la réduction

Problème : quel est l’élément neutre pour le max ?
0 ?

0 ?
max(0, -1) n’est pas égal à 0

0 ?
-∞ ?

0 ?
-∞ ?
souci : ce n’est pas un entier

0 ?
-∞ ?
Integer.MIN_VALUE ?

0 ?
-∞ ?
Integer.MIN_VALUE ?
souci pour convertir en long, et vice-versa

Réponse : il n’y a pas d’élément neutre pour le max

Problème : quel est la valeur par défaut pour le max ?

Problème : quel est la valeur par défaut pour le max ?
Réponse : il n’y a pas de valeur par défaut pour le max

Quelle est alors le type de retour pour max() ?
... max =

Si on prend int, alors la valeur par défaut est 0
... max =

Si on prend int, alors la valeur par défaut est 0
Si on prend Integer, alors la valeur par défaut est null
... max =

On a besoin d’un nouveau concept : Optional
Optional<Integer> max =

Optional
Un optional encapsule un objet
Peut être vide
Optional<String> opt = ... ;
if (opt.isPresent()) {
String s = opt.get() ;
} else {
...
}

Optional
Peut être vide
} else {
...
}
String s = opt.orElse("") ; // défini une valeur par défaut
// applicative

Optional
Peut être vide
} else {
...
}
String s = opt.orElseThrow(MyException::new) ; // construction lazy

Retour sur la réduction
Méthodes de réduction :
Integer somme =
Optional<Integer> opt =
stream.reduce((age1, age2) -> age1 + age2) ;

Remarque sur la réduction
Une réduction ne retourne pas de Stream :
- max(), min()
- count()
Réduction booléennes :
- allMatch(), noneMatch, anyMatch()
Retourne un Optional
- findFirst(), findAny() (si le Stream est vide ?)

Remarque sur la réduction
Dans tous les cas, ces réductions retournent une valeur
Elles ne peuvent donc pas être évaluées de façon lazy
Elles déclenchent les opérations !
Ce sont les opérations terminales

Opération terminale
... =
persons.map(person -> person.getAge()) // retourne Stream<Integer>
.filter(age -> age > 20) // retourne Stream<Integer>
.min(Comparator.naturalOrder()) ;

Écriture d’un map / filter / reduce
Optional<Integer> age =
persons.map(person -> person.getAge()) // retourne Stream<Integer>
.filter(age -> age > 20) // retourne Stream<Integer>
.min(Comparator.naturalOrder()) ; // opération terminale

persons.map(person -> person.getLastName())
.allMatch(length < 20) ; // opération terminale

Intérêt de tout faire dans la même boucle
persons.map(person -> person.getLastName())
.allMatch(length < 20) ; // opération terminale

Un objet qui permet de définir des traitements sur des jeux
de données arbitrairement grands
Typiquement : map / filter / reduce
Approche pipeline :
1) on définit des opérations
2) on lance les opérations

Comment un Stream est-il fait ?
Que se passe-t-il lors de la construction d’un Stream ?
List<Person> persons = new ArrayList<>() ;
// interface Collection
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}

// classe StreamSupport
public static <T> Stream<T> stream(
Spliterator<T> spliterator, boolean parallel) {
Objects.requireNonNull(spliterator) ;
return new ReferencePipeline.Head<>(
spliterator,
StreamOpFlag.fromCharacteristics(spliterator),
parallel) ;
}

// classe ArrayList
@Override
public Spliterator<E> spliterator() {
return new ArrayListSpliterator<>(this, 0, -1, 0);
}

Le Spliterator encapsule la logique d’accès aux données
Celui d’ArrayList manipule le tableau
// classe ArrayList
@Override
public Spliterator<E> spliterator() {
return new ArrayListSpliterator<>(this, 0, -1, 0);
}

Fonction du Spliterator
Méthodes à implémenter
Consomme le prochain élément s’il existe
// interface Spliterator
boolean tryAdvance(Consumer<? super T> action);

Utilisée par le parallélisme : divise les données en deux,
suivant des règles précises
Spliterator<T> trySplit();

Retourne une estimation du nombre d’éléments de ce
Stream
long estimateSize();

default void forEachRemaining(Consumer<? super T> action) {
do { } while (tryAdvance(action));
}
default long getExactSizeIfKnown() {
return (characteristics() & SIZED) == 0 ? -1L : estimateSize();
}

Implémentations
int characteristics();
// pour ArrayList
public int characteristics() {
return Spliterator.ORDERED |
Spliterator.SIZED |
Spliterator.SUBSIZED;
}

Implémentations
int characteristics();
// pour HashSet
public int characteristics() {
return (fence < 0 || est == map.size ? Spliterator.SIZED : 0) |
Spliterator.DISTINCT;
}

Caractéristiques d’un Stream
Un Stream porte des caractéristiques
Caractéristique
ORDERED L’ordre a un sens
DISTINCT Pas de doublon
SORTED Trié
SIZED Le cardinal est connu
NONNULL Pas de valeurs nulles
IMMUTABLE Ne peut pas être modifié
CONCURRENT Autorise le parallélisme
SUBSIZED Le cardinal est connu

Les opérations changent la valeur des caractéristiques
Méthode Mets à 0 Mets à 1
Filter SIZED -
Map DISTINCT, SORTED -
FlatMap DISTINCT, SORTED, SIZED -
Sorted - SORTED, ORDERED
Distinct - DISTINCT
Limit SIZED -
Peek - -
Unordered ORDERED -

Les caractéristiques d’un Stream sont prise en compte à la
consommation
// HashSet
HashSet<String> strings = ... ;
strings.stream()
.distinct() // ne déclenche pas de traitement
.sorted()
.collect(Collectors.toList()) ;

Implémentations d’un Stream
Complexe
Partagé en deux :
1) partie algorithmique, on n’a pas envie d’y toucher
2) partie accès aux données : faite pour être surchargée !

Apparté sur les Comparator
On a écrit :
// interface Comparator
Comparator cmp = Comparator.naturalOrder() ;

On a écrit :
Comparator cmp = Comparator.naturalOrder() ;
@SuppressWarnings("unchecked")
public static <T extends Comparable<? super T>>
Comparator<T> naturalOrder() {
return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
}

// classe Comparators
enum NaturalOrderComparator
implements Comparator<Comparable<Object>> {
INSTANCE;
public int compare(Comparable<Object> c1, Comparable<Object> c2) {
return c1.compareTo(c2);
}
public Comparator<Comparable<Object>> reversed() {
return Comparator.reverseOrder();
}
}

On peut écrire :
Comparator cmp =
Comparator.comparing(Person::getLastName)
.thenComparing(Person::getFirstName)
.thenComparing(Person::getAge) ;

Méthode comparing()
public static
<T, U> Comparator<T>
comparing(Function<T, U> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return
(c1, c2) ->
keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}

public static
<T, U extends Comparable<U>> Comparator<T>
comparing(Function<T, U> keyExtractor) {
return (Comparator<T>)
(c1, c2) ->
}

public static
<T, U extends Comparable<? super U>> Comparator<T>
comparing(Function<? super T, ? extends U> keyExtractor) {
return (Comparator<T> & Serializable)
(c1, c2) ->
}

Méthode thenComparing()
default
<U> Comparator<T>
thenComparing(Function<T, U> keyExtractor) {
return thenComparing(comparing(keyExtractor));
}

default
<U extends Comparable<? super U>> Comparator<T>
thenComparing(Function<? super T, ? extends U> keyExtractor) {
return thenComparing(comparing(keyExtractor));
}

default Comparator<T> thenComparing(Comparator<? super T> other) {
Objects.requireNonNull(other);
return (Comparator<T> & Serializable) (c1, c2) -> {
int res = compare(c1, c2);
return (res != 0) ? res : other.compare(c1, c2);
};
}

Petit bilan
API Stream
- opérations intermédiaires
- opérations terminales
- implémentations à deux niveaux

Opérations stateless / stateful
Le code suivant :
… sélectionne les 1000 premières personnes
ArrayList<Person> persons = ... ;
Stream<Persons> stream = persons.limit(1_000) ;

Le code suivant :
… sélectionne les 1000 premières personnes
Cette opération a besoin d’un compteur
Parallélisme ?
Stream<Persons> stream = persons.limit(1_000) ;

Le code suivant :
List<String> names =
persons.map(Person::getLastName)

Le code suivant :
« les noms des personnes apparaissent dans le même ordre
que les personnes »

Le code suivant :
Parallélisme ?

Le code suivant :
Parallélisme ?
.unordered()

Bilan sur les Stream
Un Stream a un état
On peut définir des opérations sur un Stream :
- intermédiaires & terminales
- stateless & stateful
Les traitements sur un Stream peuvent être parallélisés

Stream & performance
Deux éléments :
- traitements lazy
- traitements parallèles

Deux éléments :
- traitements lazy
- traitements parallèles
Stream<T> versus IntStream, LongStream, DoubleStream

Retour sur l’exemple
persons.stream()
.map(Person::getAge)
.filter(age -> age > 20)
.sum() ;

persons.stream() // Stream<Person>
.map(Person::getAge)
.sum() ;

.map(Person::getAge) // Stream<Integer> boxing 
.sum() ;

.filter(age -> age > 20) // Stream<Integer> re-boxing re-
.sum() ;

.sum() ; // pas de méthode sum() sur Stream<T>

.mapToInt(age -> age.getValue()) // IntStream 
.sum() ;

.mapToInt(Integer::getValue) // IntStream 
.sum() ;

.mapToInt(Person::getAge) // IntStream 
.filter(age -> age > 20) // IntStream 
// .mapToInt(Integer::getValue)
.sum() ;

int sum =
.sum() ;

??? =
.max() ;

OptionalInt opt =
.max() ;

??? =
.average() ;

OptionalInt opt =
.average() ;

Calcule en une passe : count, sum, min, max
Et donc aussi average
IntSummaryStatistics stats =
persons.stream()
.mapToInt(Person::getAge)
.summaryStatistics() ;

Parallélisation
Construction d’un Stream parallèle
Construit sur un Fork / Join construit au niveau de la JVM
Stream<Person> stream1 = persons.parallelStream() ;
Stream<Person> stream2 = persons.stream().parallel() ;

Parallélisation
On peut imposer deux choses :
- le nombre de cœurs sur lequel le FJ Pool va s’installer
- Le FJ Pool lui-même !

Parallélisation
Par défaut les ForkJoinTask s’exécutent dans le « common
pool », un FJ Pool créé au niveau de la JVM
Le taux de parallélisme de ce pool est le nombre de cœurs
On peut le fixer :
System.setProperty(
"java.util.concurrent.ForkJoinPool.common.parallelism", 2) ;

Parallélisation
On peut aussi imposer le FJ Pool dans lequel les traitements
sont faits
ForkJoinPool fjp = new ForkJoinPool(2) ;
fjp.submit(
() -> //
persons.stream().parallel() // implémentation de
.mapToInt(p -> p.getAge()) // Callable<Integer>
.filter(age -> age > 20) //
.average() //
).get() ;

Réduction
Généralisons la réduction

Réduction
Bien sûr, une réduction peut être vue comme une agrégation
au sens SQL (sum, min, max, avg, etc…)

Réduction
Bien sûr, une réduction peut être vue comme une agrégation
au sens SQL (sum, min, max, avg, etc…)
On peut voir les choses de façon plus générale

Réduction
Exemple : la somme

Réduction
Exemple : la somme
Un « container » résultat : un entier, de valeur initiale 0

Réduction
Exemple : la somme
Un « container » résultat : un entier, de valeur initiale 0
Une opération « ajouter » : ajoute un élément au container
Une opération « combiner » : fusionner deux containers
utilisée si l’on parallélise le traitement

Réduction
Remarque sur la valeur initiale

Réduction
Il s’agira de la valeur retournée en cas de réduction sur un
ensemble vide !

Réduction
Il s’agira de la valeur retournée en cas de réduction sur un
ensemble vide !
… c’est donc l’élément neutre de la réduction …

Réduction
Certaines réduction ont donc un problème :
- max,min
- average

Réduction
Donc une réduction peut se définir par trois opérations :
- Création d’un container résultat
- Ajout d’un élément à un container
- Fusion de deux container

Réduction
Modélisation, trois opérations :
- constructeur : Supplier
- accumulateur : Function
- combiner : Function

Réduction
Exemple 1 :
() -> new StringBuffer() ;

Réduction
Exemple 1 :
(StringBuffer sb, String s) -> sb.append(s) ;

Réduction
Exemple 1 :
(StringBuffer sb, String s) -> sb.append(s) ;
(StringBuffer sb1, StringBuffer sb2) -> sb1.append(sb2) ;

Réduction
Exemple 1 : concaténation de chaîne de caractères
StringBuffer::new
StringBuffer::append
StringBuffer::append

Réduction : mise en œuvre
Exemple 1 : accumulation dans un StringBuffer
StringBuffer result =
persons.stream()
.map(Person::getLastName)
.collect(
StringBuffer::new, // constructor
StringBuffer::append, // accumulator
StringBuffer::append // combiner
) ;

Réduction : collectors
Exemple 1 : utilisation d’un collector
String result =
persons.stream()
.collect(
Collectors.joining()
) ;

Réduction
Exemple 2 :
() -> new ArrayList() ;

Réduction
Exemple 2 :
(ArrayList list, E e) -> list.add(e) ;

Réduction
Exemple 2 :
(ArrayList list, E e) -> list.add(e) ;
(ArrayList list1, ArrayList list2) -> list1.addAll(list2) ;

Réduction
Exemple 2 : accumulation dans une liste
ArrayList::new
ArrayList::add
ArrayList::addAll

ArrayList<String> names =
persons.stream()
.collect(
ArrayList::new, // constructor
ArrayList::add, // accumulator
ArrayList::addAll // combiner
) ;

ArrayList<String> names =
persons.stream()
.collect(
ArrayList::new, // constructor
Collection::add, // accumulator
Collection::addAll // combiner
) ;

HashSet<String> names =
persons.stream()
.collect(
HashSet::new, // constructor
Collection::add, // accumulator
Collection::addAll // combiner
) ;

List<String> result =
persons.stream()
.collect(
Collectors.toList()
) ;

Set<String> result =
persons.stream()
.collect(
Collectors.toSet()
) ;

TreeSet<String> result =
persons.stream()
.collect(
Collectors.toCollection(TreeSet::new)
) ;

String result =
persons.stream()
.collect(
Collectors.joining(", ")
) ;

List<String> result =
persons.stream()
.collect(
Collectors.toList()
) ;

Set<String> result =
persons.stream()
.collect(
Collectors.toSet()
) ;

Collectors
Classe Collectors : 33 méthodes statiques
Boite à outils !

Collectors : groupingBy
Table de hachage : age / liste des personnes
Map<Integer, List<Person>> result =
persons.stream()
.collect(
Collectors.groupingBy(Person::getAge)
) ;

Table de hachage : age / nombre de personnes
Map<Integer, Long> result =
persons.stream()
.collect(
Collectors.groupingBy(
Person::getAge,
Collectors.counting() // « downstream collector »
)
) ;

Table de hachage : age / liste des noms des personnes
Map<Integer, List<String>> result =
persons.stream()
.collect(
Person::getAge,
Collectors.mapping( //
Person::getLastName // downstream collector
) //
)
) ;

Map<Integer, String> result =
persons.stream()
.collect(
Person::getAge,
Collectors.mapping( // 1er downstream collector
Person::getLastName
Collectors.joining(", ") // 2ème downstream collector
)
)
) ;

Map<Integer, TreeSet<String>> result =
persons.stream()
.collect(
Person::getAge,
Collectors.mapping(
Person::getLastName
)
)
) ;

TreeMap<Integer, TreeSet<String>> result =
persons.stream()
.collect(
Person::getAge,
TreeMap::new,
Collectors.mapping(
Person::getLastName
)
)
) ;

Bilan intermédiaire
Stream + Collectors =
Nouveaux outils pour le map / filter / reduce
1) exécutions lazy
2) exécutions parallèle
Des exemples à venir…
… mais pour le moment …

@JosePaumard
Coffee time !
#Stream8

Java 8 Streams & Collectors
Patterns, performance, parallélisation
@JosePaumard
#Stream8

Cas d’utilisation
« Houston, we have a problem »
https://github.com/JosePaumard/jdk8-lambda-tour

Fichier CSV contenant les MacDo US
-149.95038,61.13712,"McDonalds-Anchorage,AK","3828 W Dimond Blvd, Anchorage,AK, (907) 248-0597"
-149.93538,61.18167,"McDonalds-Anchorage,AK","4350 Spenard Rd, Anchorage,AK, (907) 243-5122"
http://introcs.cs.princeton.edu/java/data/

Fichier CSV contenant les MacDo US
-149.95038,61.13712,"McDonalds-Anchorage,AK","3828 W Dimond Blvd, Anchorage,AK, (907) 248-0597"
-149.93538,61.18167,"McDonalds-Anchorage,AK","4350 Spenard Rd, Anchorage,AK, (907) 243-5122"
try (Stream<String> lines =
Files.lines(Paths.get("files", "mcdonalds.csv"))) {
...
}

McDonald : compter les villes
1ère solution
long nTowns =
mcdos.stream()
.map(McDonald::city) // mcdo -> mcdo.city()

1ère solution
long nTowns =
mcdos.stream()
.collect(Collectors.toSet())

1ère solution
long nTowns =
mcdos.stream()
.collect(Collectors.toSet())
.size() ;

2ème solution :
long nTowns =
mcdos.stream()
.distinct()
.collect(Collectors.counting()) ;

3ème solution :
long nTowns =
mcdos.stream()
.distinct()
.count() ;

McDonald : la ville qui en a le plus
1ère étape : histogramme ville / # de mcdos
C’est une table de hachage !
Map<String, Long> map =
mcdos.stream()
.collect(
Collectors.groupingBy( // table de hachage
)
) ;

mcdos.stream()
.collect(
McDonald::city, // les clés sont les villes
)
) ;

mcdos.stream()
.collect(
McDonald::city,
Collectors.counting() // downstream
)
) ;

2ème étape : extraire la clé associée à la plus grande valeur

Il s’agit d’un max

- Sur quel ensemble ?

- Au sens de quel comparateur ?

- L’ensemble des paires clés / valeurs

- L’ensemble des paires clés / valeurs
- Le comparateur compare les valeurs

map.entrySet() // Set des paires clés / valeurs

.stream()
.max( // on prend le max
) ;

.stream()
Comparator.comparing(entry -> entry.getValue())
) ;

.stream()
Comparator.comparing(Map.Entry::getValue)
) ;

.stream()
Map.Entry.comparingByValue() // comparingByKey()
) ;

Optional<Map.Entry<String, Long>> opt =
.stream()
Map.Entry.comparingByValue() // comparingByKey()
) ;

McDonald : n villes qui en ont le plus
Plus compliqué…
1) Trier les paires clés / valeurs

McDonald : n villes qui en ont le plus
Plus compliqué…
1) Trier les paires clés / valeurs
2) Prendre les n plus grandes

Tri de l’ensemble des paires clés / valeurs
.stream()
.sorted( // tri
Comparator.comparing(entry -> -entry.getValue())
)

.stream()
.sorted( // tri
)
.limit(n) // n : nombre de valeurs que l’on veut

List<Map.Entry<String, Long>> result =
.stream()
.sorted( // tri
)
.limit(n) // n : nombre de valeurs que l’on veut

Cas d’utilisation
« Shakespeare joue au Scrabble »

Scrabble
Deux fichiers :
- les mots autorisés au Scrabble
- les mots utilisés par Shakespeare

Scrabble
Deux fichiers :
- les mots autorisés au Scrabble
- les mots utilisés par Shakespeare
Un peu de doc (Wikipedia) :
private static final int [] scrabbleENScore = {
// a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z
1, 3, 3, 2, 1, 4, 2, 4, 1, 8, 5, 1, 3, 1, 1, 3, 10, 1, 1, 1, 1, 4, 4, 8, 4, 10} ;

Scrabble : score d’un mot
1ère question : calculer le score d’un mot
B O N J O U R
3 1 1 8 1 1 1 // lecture du tableau scrabbleENScore

B O N J O U R
3 1 1 8 1 1 1 // lecture du tableau scrabbleENScore
SUM
= 16

B O N J O U R // stream des lettres du mot « bonjour »
3 1 1 8 1 1 1 // mapping : lettre -> score de chaque lettre
SUM
= 16

sum()
= 16

sum()
= 16
word -> word.chars() // stream des lettres du mot
.map(lettre -> scrabbleENScore[lettre – 'a'])

sum()
= 16
word -> word.chars() // stream des lettres du mot, type IntStream 
.sum() ; // existe sur IntStream

sum()
= 16
Function<String, Integer> score =
word -> word.chars() // stream des lettres du mot, type IntStream 
.sum() ; // existe sur IntStream

= map / reduce

Scrabble : score de Shakespeare
2ème question : calculer le meilleur score de Shakespeare

1) Histogramme des mots en fonction de leur score

2) max sur les clés

 table de hachage : groupingBy
2) max sur les clés
 on sait faire

shakespeareWords.stream()
.collect(
score // fonction de calcul de score
)
)

Map<Integer, List<String>> map =
.collect(
score // fonction de calcul de score
)
) ;

.collect(
score
) // Map<Integer, List<String>>
)
.entrySet()
.stream() // Map.Entry<Integer, List<String>>
.max(Map.Entry.comparingByKey()) ;

Optional<Map.Entry<Integer, List<String>> opt =
.collect(
score
)
.entrySet()

3ème question : limiter aux mots autorisés au Scrabble
.filter(word -> scrabbleWords.contains(word))
.collect(
score
)
.entrySet()

.filter(scrabbleWords::contains)
.collect(
score
)
.entrySet()

= problème de filter / reduce

Question : le mot en question est-il possible au Scrabble ?

Il n’y a qu’un seul ‘Z’ au Scrabble anglais…
private static final int [] scrabbleENDistribution = {
9, 2, 2, 1, 12, 2, 3, 2, 9, 1, 1, 4, 2, 6, 8, 2, 1, 6, 4, 6, 4, 2, 2, 1, 2, 1} ;

Il n’y a qu’un seul ‘Z’ au Scrabble anglais…
Il faut vérifier le nombre d’utilisation de chaque lettre
private static final int [] scrabbleENDistribution = {
9, 2, 2, 1, 12, 2, 3, 2, 9, 1, 1, 4, 2, 6, 8, 2, 1, 6, 4, 6, 4, 2, 2, 1, 2, 1} ;

Scrabble : mot possible ?
4ème question : peut-on écrire ce mot ?
B U Z Z A R D // le mot

B U Z A R D // les lettres utilisées

1 1 2 1 1 1 // l’occurrence de chaque lettre -> groupingBy

1 1 2 1 1 1 // l’occurrence de chaque lettre
2 4 1 9 6 1 // les lettres disponibles

T T F T T T // il faut que tout soit à TRUE -> allMatch

word -> word.chars() // IntStream 
.mapToObj(Integer::new) // Stream<Integer>

.collect(
)
) ;

.collect( // Map<Integer, Long>
letter -> letter,
Collectors.counting()
)
) ;

Function.identity(),
)
) ;

Function<String, Map<Integer, Long>> letterHisto =
)
) ;

Predicate<String> canWrite =
word -> letterHisto
.apply(word) // Map<Integer, Long>
.entrySet()
.stream() // Map.Entry<Integer, Long>

word -> letterHisto
.entrySet()
.allMatch(
) ;

word -> letterHisto
.entrySet()
.allMatch(
entry ->
) ;

word -> letterHisto
.entrySet()
.allMatch(
entry ->
entry.getValue() <= // besoin en lettres
) ;

word -> letterHisto
.entrySet()
.allMatch(
entry ->
entry.getValue() <= // besoin en lettres
scrabbleENDistrib[entry.getKey() – 'a'] // lettres dispos
) ;

.filter(canWrite)
.collect(
score
)
.entrySet()

= problème de map / reduce

Scrabble : et si l’on prend les blancs ?
5ème question : et si l’on utilise les blancs disponibles ?

Deux impacts :

Deux impacts :
- impact sur les mots que l’on peut faire

Deux impacts :
- impact sur les mots que l’on peut faire
- impact sur le calcul du score

Comment déterminer si un mot est accepté ?

Critère : pas plus de deux blancs

Critère : pas plus de deux blancs
On peut écrire une fonction qui calcule le nombre de blancs
utilisés pour un mot

0 0 1 0 0 0 // nombre de blancs nécessaires
// il s’agit d’un max !

0 0 1 0 0 0 // nombre de blancs nécessaires
// il s’agit d’un max !
Integer.max(
0,
entry.getValue() - // lettres nécessaires
scrabbleEnDistrib[entry.getKey() – 'a'] // lettres dispo

Function<String, Integer> nBlanks =
word -> letterHisto.apply(word)
.entrySet()
.stream()
.mapToInt( // IntStream -> sum() dispo
Integer.max(
0,
entry.getValue() -
scrabbleEnDistrib[entry.getKey() – 'a']
)
)
.sum() ;

.filter(word -> nBlanks.apply(word) <= 2)
.collect(
score
)
)
.entrySet()
.stream()

Scrabble : score avec les blancs ?
6ème question : compter les points avec les blancs ?

1 1 1 1 1 1 // lettres effectivement utilisées

// il s’agit d’un min !

* * * * * *
3 1 10 1 1 2 // score individuel de chaque lettre

* * * * * *
3 1 10 1 1 2 // score individuel de chaque lettre
SUM

.entrySet()
.stream()
.mapToInt(
.sum() ;

.entrySet()
.stream()
.mapToInt(
entry ->
.sum() ;

.entrySet()
.stream()
.mapToInt(
entry ->
scrabbleENScore[entry.getKey() – 'a']* // score de
// la lettre
.sum() ;

.entrySet()
.stream()
.mapToInt(
entry ->
scrabbleENScore[entry.getKey() – 'a']*
Integer.min(
)
.sum() ;

.entrySet()
.stream()
.mapToInt(
entry ->
scrabbleENScore[entry.getKey() – 'a']*
Integer.min(
entry.getValue(), // nombre de lettres dans le mot
scrabbleENDistrib[entry.getKey() – 'a']
)
.sum() ;

Scrabble : et sur le plateau de jeu ?
7ème question : le « lettre compte double » ?

6 solutions pour poser le mot :
- utilisation de la case de droite = 3 lettres de la fin du mot
- utilisation de la case de gauche = 3 lettres du début

Solution :
- prendre le max des 3 dernières lettres
- avec le max des 3 premières lettres
…si le mot fait 7 lettres !

Traduit en Java, le max est pris sur que ensemble ?
word.chars().skip(4) // 1er flux
word.chars().limit(Integer.max(0, word.length() - 4)) // 2ème flux

Le max de ces deux flux, puis le max des ces deux max

Concaténer ces flux ?

IntStream.concat(
word.chars().skip(4)
word.chars().limit(Integer.max(0, word.length() - 4))
)
.map(scrabbleENScore)
.max()

Problème : concat ne se parallélise pas bien…
IntStream.concat(
)
.max()

7ème question : « lettre compte double » ?
Stream.of(
) // retourne un Stream de Stream !

Stream.of(
)
.flatMap(Function.identity())
.max()

Que faire de cet Optional ?
Stream.of(
)
.max()

Que faire de cet Optional ? … qui peut être vide !
Stream.of(
)
.max()

Stream.of(
)
.max()
.ifPresent( )

List<Integer> list = new ArrayList<>() ;
Stream.of(
)
.max()
.ifPresent(list::add)

Stream.of(
)
.max()
.ifPresent(list::add) ;
list.stream().max(Comparator.naturalOrder()).get()

list.add(0) ;
Stream.of(
)
.max()
list.stream().max(Comparator.naturalOrder()).get()

Function<String, Integer> scoreAtPosition =
word -> {
list.add(0) ;
Stream.of(
)
.flatMap(Function.identity()).map(scrabbleENScore).max()
return list.stream().max(Comparator.naturalOrder()).get()
}

= problème de map / reduce !

Cas d’utilisation
« des films et des acteurs »

Des films et des acteurs
Fichier : « movies-mpaa.txt »
Contient 14k films américains de 1916 à 2004
Avec :
- le titre
- l’année de sortie
- la liste des acteurs

Fichier : « movies-mpaa.txt »
Contient 14k films américains de 1916 à 2004
Avec :
- le titre
- l‘année de sortie
- la liste des acteurs
Référence 170k acteurs différents

1ère question : quel acteur a joué dans le plus de films ?

Construire une table de hachage :
- les clés sont les acteurs
- les valeurs sont le nombre de films

Construction de l’ensemble des acteurs
Set<Actor> actors =
movies.stream()
.flatMap(movie -> movie.actors().stream())
.collect(Collector.toSet()) ;

actors.stream()
.collect(
)
.entrySet().stream()
.max(Map.Entry.comparingByValue()).get() ;

actors.stream()
.collect(
Collectors.toMap(
)
)

actors.stream()
.collect(
Collectors.toMap(
actor -> movies.stream()
.filter(movie -> movie.actors().contains(actor))
.count()
)
)

actors.stream().parallel() // T = 40s 
.collect(
Collectors.toMap(
actor -> movies.stream()
.filter(movie -> movie.actors().contains(actor))
.count()
)
)

movies.stream()
.map(movie -> movie.actors().stream()) // stream de stream !

movies.stream()
.flatMap(movie -> movie.actors().stream()) // stream d’acteurs
.collect(
)

movies.stream()
.collect(
)
)

Réponse : Frank Welker

2ème question : idem, en une année ?

movies.stream()
.collect(
)
)

movies.stream()
.collect(
// construire une table de hachage année / nombre
)
)

On peut construire une table de hachage :
- les clés sont les années
- les valeurs sont … des tables de hachage

- dont les clés sont les acteurs

- dont les clés sont les acteurs
Et on veut le max par nombre de films

On va construire le collector à la main !
movies.stream().collect(
Collector.groupingBy(
movie -> movie.releaseYear(),
// downstream construit à la main
)
)

Ce collector construit une table de hachage :
- les clés sont les acteurs
- les valeurs sont le nombre de films joués dans l’année

1) la construction de la table résultat
Supplier<Map<Actor, AtomicLong>> supplier =
() ->
new HashMap<Actor, AtomicLong>() ;

2) l'ajout d’un élément à une table partiellement remplie

BiConsumer<Map<Actor, AtomicLong>, Movie> accumulator =
(map, movie) -> movie.actors().forEach(
actor ->
) ;

actor ->
map.get(actor).incrementAndGet() // map.getActor != null
) ;

actor ->
map.put(actor, new AtomicLong()) // map.getActor == null
) ;

actor -> map.computeIfAbsent(
actor, // la clé
// exécute ce code si pas de clé
) // et retourne la valeur
.incrementAndGet()
) ;

actor -> map.computeIfAbsent(
actor,
a -> new AtomicLong() // exécute ce code si absent
) // et retourne la valeur
.incrementAndGet()
) ;

3) la fusion de deux tables partiellement remplies

BinaryOperator<Map<Actor, AtomicLong>> combiner =
(map1, map2) -> {
return map1 ;
} ;

(map1, map2) -> {
map2.entrySet().stream().forEach(
) ;
return map1 ;
} ;

(map1, map2) -> {
entry -> map1.computeIfAbsent(
entry.getKey(), a -> new AtomicLong()
)
) ;
return map1 ;
} ;

(map1, map2) -> {
entry -> map1.computeIfAbsent(
entry.getKey(), a -> new AtomicLong()
).addAndGet(entry.getValue().get())
) ;
return map1 ;
} ;

Collector.of(
supplier, accumulator, combiner,
)
)
) // Map<Integer, Map<Actor, AtomicLong>>

Collector.of(
supplier, accumulator, combiner,
new Collector.Characteristics [] {
Collector.Characteristics.CONCURRENT.CONCURRENT
}
)
)
) // Map<Integer, Map<Actor, AtomicLong>>

Dernière étape : extraire le max
// Map<Integer, Map<Actor, AtomicLong>>

1) extraire Map<Integer, Map.Entry<Actor, AtomicLong>>

1) extraire Map<Integer, Map.Entry<Actor, AtomicLong>>
2) extraire le max de cette table

map.entrySet().stream().collect(
Collectors.toMap(
entry -> entry.getKey(), // on ne change pas la clé
// Map.Entry<Actor, AtomicLong>
)
)

Collectors.toMap(
entry -> entry.getKey(),
entry -> entry.getValue().entrySet().stream()
.max(
)
.get()
)
)

Collectors.toMap(
.max(
Map.Entry.comparingByValue(
)
.get()
)
)

Collectors.toMap(
.max(
Comparator.comparing(AtomicLong::get))
)
.get()
)
)

Collectors.toMap(
.max(
Comparator.comparing(AtomicLong::get))
)
.get()
)
) // Map<Integer, Map.Entry<Actor, AtomicLong>>

// Map<Integer, Map.Entry<Actor, AtomicLong>>
map2.entrySet().stream()
.max(
Comparator.comparing(
)
)
.get() ;

.max(
entry -> entry.getValue().getValue().get())
)
)
.get() ;

.max(
entry -> entry.getValue().getValue().get())
)
)
.get() ; // Map.Entry<Integer, Map.Entry<Actor, AtomicLong>>

Réponse : Phil Hawn, en 1999
a joué dans 24 films

Cas d’utilisation

Conclusion
Streams + Collectors = obsolescence du pattern Iterator !

Conclusion
Combinés avec les lambdas =
nouvelle façon d’écrire les applications en Java

Conclusion
Combinés avec les lambdas =
nouvelle façon d’écrire les applications en Java
- le développement
- l’architecture

Conclusion
Un peu de doc :

Java 8-streams-collectors-patterns

Contenu connexe

Tendances (20)

Plus de José Paumard (20)

Dernier (20)

Java 8-streams-collectors-patterns