Les slides de ma présentation à Devoxx France 2017. Introduite en Java 8, l'API Collector vit dans l'ombre de l'API Stream, ce qui est logique puisqu'un collecteur doit se connecter à un stream pour fonctionner. Le JDK est organisé de sorte que l'on utilise surtout les collectors sur étagère : groupingBy, counting et quelques autres. Ces deux éléments masquent non seulement le modèle de traitement de données des collectors, mais aussi sa puissance et ses performances. Ces présentation parle des collectors qui existent et qu'il faut connaître, ceux que l'on peut créer, ceux dont on se doute que l'on peut les créer une fois que l'on comprend un peu les choses, et les autres, tant les possibilités offertes par cette API sont illimitées.

1. #DevoxxFR
L’API Collector
dans tous ses états
@JosePaumard
https://github.com/JosePaumard
https://www.slideshare.net/jpaumard
https://www.youtube.com/user/JPaumard

2. #DevoxxFR #ColJ8
@JosePaumard
Microsoft Virtual Academy

3. #DevoxxFR #ColJ8
@JosePaumard

4. #DevoxxFR #ColJ8
Questions ?
#ColJ8

5. #DevoxxFR #ColJ8
Collectors ?
Pourquoi s’intéresser aux collectors ?
▪ Partie intégrante de l’API Stream
▪ En général un peu laissée de côté

6. #DevoxxFR #ColJ8
Collectors ?
YouTube :
▪ Tutoriaux sur les Streams ~670k
▪ Tutoriaux sur les Collectors < 4,5k

7. #DevoxxFR #ColJ8
Collectors ?
Pourquoi s’intéresser aux collectors ?
▪ Partie intégrante de l’API Stream
▪ En général un peu laissée de côté
▪ Bien comprise elle peut simplifier les traitements

8. #DevoxxFR #ColJ8
movies.stream()
.flatMap(movie -> movie.actors().stream())
.collect(
Collectors.groupingBy(
Function.identity(),
Collectors.counting()
)
)
.entrySet().stream()
.max(Map.Entry.comparingByValue())
.get();

9. #DevoxxFR #ColJ8
movies.stream()
.collect(
Collectors.groupingBy(
movie -> movie.releaseYear(),
Collector.of(
() -> new HashMap<Actor, AtomicLong>(),
(map, movie) -> {
movie.actors().forEach(
actor -> map.computeIfAbsent(actor, a -> new AtomicLong()).incrementAndGet()
) ;
},
(map1, map2) -> {
map2.entrySet().stream().forEach(
entry -> map1.computeIfAbsent(entry.getKey(), a -> new AtomicLong()).addAndGet(entry.getValue().get())
) ;
return map1 ;
},
new Collector.Characteristics [] {
Collector.Characteristics.CONCURRENT.CONCURRENT
}
)
)
)
.entrySet().stream()
.collect(
Collectors.toMap(
entry5 -> entry5.getKey(),
entry5 -> entry5.getValue()
.entrySet().stream()
.max(Map.Entry.comparingByValue(Comparator.comparing(l -> l.get())))
.get()
)
.entrySet()
.stream()
.max(Comparator.comparing(entry -> entry.getValue().getValue().get()))
.get();

10. #DevoxxFR #ColJ8
Collectors ?
Pourquoi s’intéresser aux collectors ?
▪ Partie intégrante de l’API Stream
▪ En général un peu laissée de côté
▪ Bien comprise elle peut simplifier les traitements
▪ Avec quelques précautions…

11. #DevoxxFR #ColJ8
Quelques mots sur les
Stream

12. #DevoxxFR #ColJ8
Dualité dans les Streams
Dans les streams :
▪ Objet qui se connecte à une source
▪ Opérations intermédiaires / terminales
▪ Certaines opérations terminales peuvent être des
collectors
▪ Ces collectors peuvent prendre d’autres
collectors en paramètres…

13. #DevoxxFR #ColJ8
Dualité dans les Streams
Dans les streams :
▪ Toute opération sur un stream peut être
modélisée par un collector
▪ Quel intérêt ?
stream.collect(collector);

14. #DevoxxFR #ColJ8
Ou va-t-on ?
« Petit » rappel sur les streams
Les collectors qui existent
Comment étendre les collectors qui existent
Comment rendre le code lisible
Les collectors qui n’existent pas

15. #DevoxxFR #ColJ8
Opérations intermédiaires

16. #DevoxxFR #ColJ8
Un Stream c’est…
Un objet qui se connecte à une source de
données et les regarde passer
Un stream ne « contient pas » de données
stream

17. #DevoxxFR #ColJ8
stream
Change le type des données = mapping

18. #DevoxxFR #ColJ8
stream
Ne laisse pas tout passer = filtrage

19. #DevoxxFR #ColJ8
Mise à plat = flatMap
stream

20. #DevoxxFR #ColJ8
Mise à plat = flatMap
stream

21. #DevoxxFR #ColJ8
Map, Filter, FlatMap
Trois opérations qui ne stockent aucune
information pour fonctionner
Un objet entre = un objet sort, sans délai
Pas de le cas de toutes les opérations…

22. #DevoxxFR #ColJ8
Tri en fonction d’un comparateur…
Nécessite de « voir » toutes les données
stream

23. #DevoxxFR #ColJ8
stream
Distinct
Les données peuvent traverser une par
une, certaines sont éliminées

24. #DevoxxFR #ColJ8
Distinct, sorted
Sorted :
a besoin de « tout voir » pour faire le tri
Distinct :
doit « retenir ce qui passe » et laisse passer
Dans les deux cas : besoin d’un buffer

25. #DevoxxFR #ColJ8
Opérations intermédiaires
2 catégories :
- Opérations directes = stateless
- Opérations avec buffer = stateful

26. #DevoxxFR #ColJ8
Cas de limit et skip
Deux méthodes qui dépendent de l’ordre des
éléments :
- Limit = conserve les n premiers éléments
- Skip = saute les n premiers éléments
Ne gère pas un buffer mais un compteur
Besoin de voir les données « dans l’ordre »

27. #DevoxxFR #ColJ8
Opérations terminales

28. #DevoxxFR #ColJ8
Intermédiaire vs terminale
Seule une opération terminale déclenche la
consommation des éléments de la source

29. #DevoxxFR #ColJ8
Opérations terminales
Premier paquet :
- forEach
- count
- max, min
- reduce
- toArray

30. #DevoxxFR #ColJ8
Opérations terminales
Premier paquet :
- forEach
- count
- max, min
- reduce
- toArray
Consomment toutes les
données

31. #DevoxxFR #ColJ8
Opérations terminales
Deuxième paquet :
- allMatch
- anyMatch
- noneMatch
- findFirst
- findAny

32. #DevoxxFR #ColJ8
Opérations terminales
Deuxième paquet :
- allMatch
- anyMatch
- noneMatch
- findFirst
- findAny
N’ont pas besoin de
consommer toutes les
données

33. #DevoxxFR #ColJ8
Opérations terminales
Cas particuliers :
- max
- min
- reduce
Retourne un optional (cas des streams vides)
https://www.youtube.com/watch?v=Ej0sss6cq14

34. #DevoxxFR #ColJ8
Un premier collector
Et puis il y a collect !
Probablement le plus utilisé :
Prend un collector en paramètre
List<String> result =
strings.stream()
.filter(s -> s.itEmpty())
.collect(Collectors.toList());

35. #DevoxxFR #ColJ8
Un premier collector (bis)
Et puis il y a collect !
Probablement le plus utilisé :
Prend un collector en paramètre
Set<String> result =
strings.stream()
.filter(s -> s.itEmpty())
.collect(Collectors.toSet());

36. #DevoxxFR #ColJ8
Un deuxième collector
Et puis il y a collect !
Peut-être moins connu ?
Prend un collector en paramètre
String authors =
authors.stream()
.map(Author::getName)
.collect(Collectors.joining(", "));

37. Demo Time

38. #DevoxxFR #ColJ8
Un troisième collector
Construction de Map
Map<Integer, List<String>> result =
strings.stream()
.filter(s -> s.itEmpty())
.collect(
Collectors.groupingBy(
s -> s.length()
)
);

39. #DevoxxFR #ColJ8
3
4
5
one, two, three, four, five, six, seven, eight, nine, ten
one, two, six, ten
four, five, nine
three, seven, eight
groupingBy(String::length)



Map<Integer, List<String>>

40. #DevoxxFR #ColJ8
3
4
5
one, two, three, four, five, six, seven, eight, nine, ten
one, two, six, ten
four, five, nine
three, seven, eight
groupingBy(String::length, downstream)



.stream().collect(downstream)
.stream().collect(downstream)
.stream().collect(downstream)

41. #DevoxxFR #ColJ8
3
4
5
one, two, three, four, five, six, seven, eight, nine, ten
one, two, six, ten
four, five, nine
three, seven, eight
groupingBy(String::length, Collectors.counting())



4L
3L
3L
Map<Integer, Long>

42. #DevoxxFR #ColJ8
Un troisième collector (bis)
Construction de Map
Map<Integer, Long> result =
strings.stream()
.filter(s -> s.itEmpty())
.collect(
Collectors.groupingBy(
s -> s.length(), Collectors.counting()
)
);

43. Demo Time

44. #DevoxxFR #ColJ8
Un collector qui compte
Nombre d’articles par auteur

45. #DevoxxFR #ColJ8
Gent & Walsh, Beyond NP: The QSAT Phase Transition
Gent & Hoos & Prosser & Walsh, Morphing: Combining…
A1 A2
Gent
Walsh
Gent
Hoos
Prosser
Walsh
flatMap(Article::getAuthors)

46. #DevoxxFR #ColJ8
Gent & Walsh, Beyond NP: The QSAT Phase Transition
Gent & Hoos & Prosser & Walsh, Morphing: Combining…
Gent, Walsh, Gent, Hoos, Prosser, Walsh
flatMap(Article::getAuthors)
Gent
Walsh
Hoos



2L
2L
1L
Prosser  1L
groupingBy(
)
groupingBy(
identity(),
counting()
)
groupingBy(
identity(),
)

47. Demo Time

48. #DevoxxFR #ColJ8
Supply, accumulate and
combine

49. #DevoxxFR #ColJ8
Construction de listes
Reprenons le code :
List<String> result =
strings.stream()
.filter(s -> s.itEmpty())
.collect(Collectors.toList());

50. #DevoxxFR #ColJ8
stream a b b
collector
1) construire la liste
2) ajouter un élément
a b c
ArrayList

51. #DevoxxFR #ColJ8
Construction de listes
1) Construction de la liste : supplier
2) Ajout d’un élément à la liste : accumulateur
Supplier<List> supplier = () -> new ArrayList();
BiConsumer<List<E>, E> accumulator = (list, e) -> list.add(e);

52. #DevoxxFR #ColJ8
Cas parallèle
Stream
Collector
collector
1) construire la liste
2) ajouter un élément
3) fusionner
CPU 2
Stream
Collector
CPU 1

53. #DevoxxFR #ColJ8
Construction de listes
1) Construction de la liste : supplier
2) Ajout d’un élément à la liste : accumulateur
3) Combinaison de deux listes
Supplier<List> supplier = ArrayList::new;
BiConsumer<List<E>, E> accumulator = List::add;
BiConsumer<List<E>, List<E>> combiner = List::addAll;

54. #DevoxxFR #ColJ8
Construction de listes
Ce qui donne :
List<String> result =
strings.stream()
.filter(s -> s.itEmpty())
.collect(ArrayList::new,
List::add,
List::adAll);

55. #DevoxxFR #ColJ8
Construction de listes
Ce qui donne :
List<String> result =
strings.stream()
.filter(s -> s.itEmpty())
.collect(ArrayList::new,
Collection::add,
Collection::adAll);

56. #DevoxxFR #ColJ8
Construction de sets
Ce qui donne :
Set<String> result =
strings.stream()
.filter(s -> s.itEmpty())
.collect(HashSet::new,
Collection::add,
Collection::adAll);

57. #DevoxxFR #ColJ8
Concaténation de String
Plutôt qu’une liste on veut construire le
résultat dans une chaîne de caractères séparée
par des virgules :
« one, two, six »
Ne fonctionne que sur les streams de String

58. #DevoxxFR #ColJ8
Concaténation de String
Méthode collect :
strings.stream()
.filter(s -> s.length() == 3)
.collect(() -> new String(),
(finalString, s) -> finalString.concat(s),
(s1, s2) -> s1.concat(s2));

59. #DevoxxFR #ColJ8
Concaténation de String
Méthode collect :
strings.stream()
.filter(s -> s.length() == 3)
.collect(() -> new String(),
(finalString, s) -> finalString.concat(s),
(s1, s2) -> s1.concat(s2));

60. #DevoxxFR #ColJ8
Concaténation de String
Méthode collect :
strings.stream()
.filter(s -> s.length() == 3)
.collect(() -> new StringBuilder(),
(sb, s) -> sb.append(s),
(sb1, sb2) -> sb1.append(sb2));

61. #DevoxxFR #ColJ8
Concaténation de String
Méthode collect :
strings.stream()
.filter(s -> s.length() == 3)
.collect(StringBuilder::new,
StringBuilder::append,
StringBuilder::append);

62. #DevoxxFR #ColJ8
Concaténation de String
Méthode collect :
StringBuilder stringBuilder =
strings.stream()
.filter(s -> s.length() == 3)
.collect(StringBuilder::new,
StringBuilder::append,
StringBuilder::append);

63. #DevoxxFR #ColJ8
Concaténation de String
Méthode collect :
String string =
strings.stream()
.filter(s -> s.length() == 3)
.collect(StringBuilder::new,
StringBuilder::append,
StringBuilder::append)
.toString();

64. #DevoxxFR #ColJ8
Un collector
3 opérations
- supplier, construit un container de calcul
- accumulator
- combiner

65. #DevoxxFR #ColJ8
Un collector
3 opérations + 1
- supplier, construit un container de calcul
- accumulator
- combiner
- finisher, qui peut être la fonction identité

66. Demo Time

67. #DevoxxFR
Collectors custom :
1) Mapping
2) Filtrage, flat map
3) Jointures
Coffee break!

68. #DevoxxFR #ColJ8
À propos des types

69. #DevoxxFR #ColJ8
Interface Collector
public interface Collector<T, A, R> {
public Supplier<A> supplier(); // A : container intermédiaire
public BiConsumer<A, T> accumulator();// T : éléments traités
public BinaryOperator<A> combiner(); // retourne un A
public Function<A, R> finisher(); // touche finale
}

70. #DevoxxFR #ColJ8
Interface Collector
public interface Collector<T, A, R> {
public Supplier<A> supplier(); // A : container intermédiaire
public BiConsumer<A, T> accumulator();// T : éléments traités
public BinaryOperator<A> combiner(); // retourne un A
public Function<A, R> finisher(); // touche finale
public Set<Characteristics> characteristics();
}

71. #DevoxxFR #ColJ8
Type d’un collector
Décodage
- T : type des éléments du stream
- A : type du container intermédiaire
- R : type du container final
On a souvent A = R
Le finisher est souvent la fonction identité
≠

72. #DevoxxFR #ColJ8
3
4
5
one, two, three, four, five, six, seven, eight, nine, ten
one, two, six, ten
four, five, nine
three, seven, eight



groupingBy(String::length)

73. #DevoxxFR #ColJ8
3
4
5
one, two, three, four, five, six, seven, eight, nine, ten
one, two, six, ten
four, five, nine
three, seven, eight
Collector<String, ?, Map<Integer, List<String>> > c =
groupingBy(String::length)




74. #DevoxxFR #ColJ8
3
4
5
one, two, three, four, five, six, seven, eight, nine, ten
one, two, six, ten
four, five, nine
three, seven, eight
Collector<String, ?, Map<Integer, List<String>> > c =
groupingBy(String::length)




75. #DevoxxFR #ColJ8
3
4
5
one, two, three, four, five, six, seven, eight, nine, ten
one, two, six, ten
four, five, nine
three, seven, eight
Collector<String, ?, Map<Integer, List<String>> > c =
groupingBy(String::length)




76. #DevoxxFR #ColJ8
one, two, three, four, five, six, seven, eight, nine, ten
Collector<String, ?, Map<Integer, List<String>> > c =
groupingBy(
String::length,
?
)

77. #DevoxxFR #ColJ8
one, two, three, four, five, six, seven, eight, nine, ten
Collector<String, ?, Map<Integer, List<String>> > c =
groupingBy(
String::length,
Collector<String, ?, >
)

78. #DevoxxFR #ColJ8
one, two, three, four, five, six, seven, eight, nine, ten
Collector<String, ?, Map<Integer, Value>> c =
groupingBy(
String::length,
Collector<String, ?, Value>
)
counting() : Collector<T, ?, Long>

79. #DevoxxFR #ColJ8
Opérations intermédiaires

80. #DevoxxFR #ColJ8
7634L {2004, 7634L}
Map<Long, List<Entry<Integer, Long>>>

81. #DevoxxFR #ColJ8
7634L {2004, 7634L}
Map<Long, List<Entry<Integer, Long>>>
Entry<Integer, Long> -> Integer = mapping
Function<> mapper = entry -> entry.getKey();
Collectors.mapping(mapper, toList());

82. Demo Time

83. #DevoxxFR #ColJ8
Mapping et toMap
Un collector pour faire du mapping
Prend un downstream obligatoire
toMap :
stream.collect(mapping(function, downstream));
stream.collect(
toMapping(
t -> key,
t -> value));

84. #DevoxxFR #ColJ8
Collector intermédiaires
Le collector mapping intègre une opération
intermédiaire
stream.collect(mapping(function, downstream));

85. #DevoxxFR #ColJ8
Collector intermédiaires
Le collector mapping intègre une opération
intermédiaire
Intérêt ?
Pouvoir créer des downstream collectors
Un collector = intégrer le traitement d’un
stream en totalité

86. #DevoxxFR #ColJ8
Collector intermédiaires
Si l’on peut faire du mapping, pourquoi ne pas
faire du filtrage ou du flatmap ?
… on aura ces deux collectors dans Java 9

87. #DevoxxFR #ColJ8
Interface Collector
public interface Collector<T, A, R> {
public Supplier<A> supplier(); // A : container intermédiaire
public BiConsumer<A, T> accumulator();// T : éléments traités
public BinaryOperator<A> combiner(); // retourne un A
public Function<A, R> finisher(); // touche finale
public Set<Characteristics> characteristics();
}

88. #DevoxxFR #ColJ8
Collector intermédiaires
Le collector mapping intègre une opération
intermédiaire
stream.collect(mapping(function, downstream));
stream.collect(filtering(predicate, downstream));
Stream<T> donc Predicate<T>
Et Collector<T, ?, R>

89. #DevoxxFR #ColJ8
Collector intermédiaires
Le collector mapping intègre une opération
intermédiaire
Stream<T> donc Function<T, Stream<TT>>
Et Collector<TT, ?, R>
stream.collect(mapping(function, downstream));
stream.collect(flatMapping(flatMapper, downstream));

90. Demo Time

91. #DevoxxFR #ColJ8
Caractéristiques
Trois caractéristiques pour les collectors:
- IDENTITY_FINISH : le finisher est la fonction
identité
- UNORDERED : le collector ne conserve pas
l’ordre des éléments
- CONCURRENT : il est thread safe

92. #DevoxxFR #ColJ8
Application
1) L’auteur qui a le plus publié
2) L’auteur qui a le plus publié en un an

93. Demo Time

94. #DevoxxFR #ColJ8
Application
L’intérêt est de modéliser un traitement dans
un collecteur :
Pouvoir utiliser le collector en tant que
downstream pour des traitements plus
avancés

95. #DevoxxFR #ColJ8
Autre application
1) Les deux auteurs qui ont le plus publié
ensemble
2) Les deux auteurs qui ont le plus publié
ensemble en un an
Utilisation de StreamsUtils

96. #DevoxxFR #ColJ8
Gent & Walsh, Beyond NP: The QSAT Phase Transition
Gent & Hoos & Prosser & Walsh, Morphing: Combining…
Gent, Hoos, Prosser, Walsh
Gent, Walsh
{Gent, Walsh}
{Gent, Hoos} {Gent, Prosser} {Gent, Walsh}
{Hoos, Prosser} {Hoos, Walsh}
{Prosser, Walsh}
flatMap()

97. Demo Time

98. #DevoxxFR #ColJ8
Problème ?
On peut avoir un problème si le stream des
paires d’auteurs est vide
Ce qui arrive si les seuls articles sont des
articles à un auteur
Sur toute la base, pas de risque
… mais quand on regroupe par année…

99. #DevoxxFR #ColJ8
Inverser une relation

100. #DevoxxFR #ColJ8
Inversion d’une relation
On a travaillé sur la relation entre les articles et
leurs auteurs
On veut inverser cette relation : connaître les
articles par auteur

101. #DevoxxFR #ColJ8
Gent & Walsh, Beyond NP: The QSAT Phase Transition
{Art1, Gent}, {Art1, Walsh}
{Art1, {Gent, Walsh}}
flatMap()
groupingBy()

102. #DevoxxFR #ColJ8
Conclusion

103. #DevoxxFR #ColJ8
API Collector
API très riche
Un peu complexe, nécessite quelques repères
Surtout, nécessite de comprendre le
traitement que l’on veut faire

104. #DevoxxFR #ColJ8
API Collector
Un collector = un objet qui modélise un
traitement de données dans sa totalité
Peut donc être utilisé comme traitement
partiel d’un traitement plus large

105. #DevoxxFR
Merci pour votre
attention

106. #DevoxxFR
Questions ?
@JosePaumard
https://github.com/JosePaumard
https://www.slideshare.net/jpaumard
https://www.youtube.com/user/JPaumard