Techday sur Java 8 animé par Stéphane Goumard.

1. Java 8

2. Java 8
“Java 8 a établi un chiffre record d’adoption.
L’adoption de Java SE 8 depuis son lancement est de 20%
supérieur à celui de Java SE 7 sur la même période
de temps.”
“56 Nouvelles fonctionnalités”
“Java 8 devrait ainsi avoir un impact au moins aussi
important que Java 5 à son époque “
“Les arrivées des lambdas, des méthodes par défaut, des
interfaces fonctionnelles et de Stream vont modifier en
profondeur le langage et donc l'écosystème Java
tout entier.”
“18 Mars 2014”

3. Qui suis-je ?
Stéphane Goumard
Consultant Java.
Arrow Group
#Big Data
#Spark
#Hadoop
#Java
#Architecture#Dev
#NoSql
#Spring #EAI
@José Paumard Université Paris13
@Remi Forax Université Paris13
#Scub Foundation@sgoumard

4. Lambdas, Streams et Collectors
- Pattern Iterator.
GOF (Gang Of Four)

5. - Lambdas (JSR 335) Introduction par l’
exemple.
Lambdas, Streams et Collectors
Design Pattern
Iterator
Programmation
Impérative,
verbeux

6. Lambdas, Streams et Collectors
Un langage déclaratif le SQL…..
select sum(age)
from Person
where age > 20
On Décrit le Résultat
Les détails
d'exécutions sont à
la charge du SGBD

7. Lambdas, Streams et Collectors
JDK 7 Un langage
Impératif, verbeux
JDK 8 Un langage
Déclaratif + lisible
JDK8 (Lambdas,
Stream et Collector)

8. Lambdas, Streams et Collectors
1 - Map (Mapping)
- Transformer une Liste d’un certain type en une autre de
même taille et d’un autre type.
2 - Filter (Filtrage)
- Transformer une Liste d’un certain type en une liste d’une
taille différente mais du même type.
3 - Reduce (Réduction)
- Agrégation des éléments d’une liste dans un seul
élément Ex : moyenne, somme, min, max
Map Filter Reduce
Pattern
Map/Filter/Reduce

9. JDK 7 Pattern
MapReFilter/Reduce.
Lambdas, Streams et Collectors
//Implémentassions d’une
Liste Custom
//Implémenter
List Custom
//Classe anonyme
trés “verbeux”
//Pattern Iterator Impératif

10. Avant JDK8.
Lambdas, Streams et Collectors
Attention : Mon étape de réduction doit être “Associatif”
Somme (Folding) :
(i1+i2) + i3 = i1 + (i2 + i3) => OK et // OK.
Somme des carrés (Folding) :
(i1*i1) + (i2*i2) + (i3*i3) != ((i1*i1)+(i2*i2))2 + (i3*i3);
=> NOK Résultat faux mais toujours identique.
en // NOK.
- Pattern Iterator Impératif
- Non Lazy, copie d’
ArrayList pas très
performants.

11. Lambdas, Streams et Collectors
mapper = new Mapper < Person, Integer > () {
public Integer map(Person person) {
return person.getAge();
}
}
mapper = (Person person) -> person.getAge()
public interface Mapper < T, V > {
public V map (T t);
}
le compilateur reconnaît cette expression
Lambdas comme une “implémentation” du
Mapper
// 1 Méthode
JDK8
JDK7

12. Lambdas, Streams et Collectors
Plus d’une ligne de Code :
Type de retour de méthode void :
Prends plus d’un argument :

13. Lambdas, Streams et Collectors
Person p = new Person(); //Référence sur une instance.
mapper = p::getAge
Random r = Math::random; //Référence statique.
r.get(); //Math.random()
“Références de Méthodes”

14. Pour le moment :
Une expression lambda et une autre façon plus
lisible d’écrire des instances de classes
anonymes.
Lambdas, Streams et Collectors

15. Lambdas, Streams et Collectors
Avec un peu d'entraînement le code deviens plus lisible :
Encore plus simple le type de paramètre implicite :

16. Lambdas, Streams et Collectors
- Possède 1 méthode.
- Annotation
@FunctionnalInterface pas
obligatoire mais permet de
valider les interfaces à la
compilation.

17. Lambdas, Streams et Collectors
Une expression
lambda n’est pas un
objet elle a pas une
identité propre.

18. 43 Interfaces fonctionnelles dans le JDK 8.
Java.util.functions.*
● Supplier/Consumer
● Function / BiFunction
● Predicate / BiPredicate
En plus des versions construites sur les types
primitifs.
Lambdas, Streams et Collectors

19. Lambdas, Streams et Collectors
Un Supplier fournit un objet
Un Consumer consomme un
objet

20. Une Function prend un objet
et retourne un objet (Map)
Prend un objet et retourne
un boolean. (Filter)
il peut être inversé et composé des AND ou OR
Les Fonctions peuvent être chaînées et / ou composées.
Lambdas, Streams et Collectors

21. Retour sur mon projet exemple :
Implémenter le Pattern Map/Filter/Reduce sur
une collection pour calculer la somme des âges
des personnes qui ont plus de 20 ans.
Lambdas, Streams et Collectors

22. JDK 7 Pattern
MapReFilter/Reduce.
Lambdas, Streams et Collectors
//Implémentassions d’une
Liste Custom
//Implémenter
List Custom
//Classe anonyme
trés “verbeux”
//Pattern Iterator Impératif

23. Lambdas, Streams et Collectors
int sum = liste.map(personne -> personne.getAge())
.filter(age -> age> 20)
.reduce((age1, age2) -> age1 + age2);
JDK 8 Pattern MapReFilter/Reduce.
- Utiliser des Expressions Lambdas.

24. - Utiliser les Interfaces du JDK8.
- Pattern Iterator et Imperatif.
- Pas de Lazy Operations. /
allMatch
- Réduction impérative.
Lambdas, Streams et Collectors
JDK 8 Pattern MapReFilter/Reduce.

25. État :
On a besoin d’un nouveau concept pour traiter
les listes de grandes tailles en mode lazy et
également pouvoir déléguer l’application des
opérations sur les listes au JDK.
Lambdas, Streams et Collectors

26. Lambdas, Streams et Collectors
int sum = liste.map(personne -> personne.getAge())
.filter(age -> age> 20)
.reduce((age1, age2) -> age1 + age2);
int sum = liste.stream.map(
personne -> personne.getAge())
.filter(age -> age> 20)
.reduce((age1, age2) -> age1 + age2);
“Une nouvelle Interface sur l’API
Collection Stream”

27. Lambdas, Streams et Collectors
Une Nouvelle Méthode sur l’API Collection hum….
- Problème l’ensemble des
Collections “Custom”
développés ne Compile plus !
- On a besoin d’une nouvelle notion !

28. Interfaces par défaut Java 8
Lambdas, Streams et Collectors
- Mot clé default.
- Plus besoin d’implémenter.
Questions :
- classe Abstraite ? Non (Pas d’état, de variable)
- Héritage Multiple ? Oui type et impl mais pas d’état.
- Alors les conflits ? Oui mais Gérer avec des règles.

29. Lambdas, Streams et Collectors
Interfaces par défaut Java 8
- - Erreur de Compilation (dans l’IDE)

30. Lambdas, Streams et Collectors
Interfaces par défaut Java 8
- La Classe Gagne

31. Lambdas, Streams et Collectors
Interfaces par défaut Java 8
- Le plus spécifique gagne !

32. Lambdas, Streams et Collectors
Interfaces avec méthode “static” Java 8
Note : D'après Remi Forax cette possibilité existe
depuis les débuts dans le JDK, elle était simplement
bridée par le compilateur.

33. État :
On a besoin d’un nouveau concept pour traiter
les listes de grandes tailles en mode lazy et
également pouvoir déléguer l’application des
opérations sur les listes au JDK.
Lambdas, Streams et Collectors

34. Lambdas, Streams et Collectors
int sum = liste.stream.map(
personne -> personne.getAge())
.filter(age -> age> 20)
.reduce((age1, age2) -> age1 + age2);
On a besoin d’un nouveau concept pour traiter
les listes de grandes tailles en mode lazy et
également pouvoir déléguer l’application des
opérations sur les listes au JDK.
API Stream

35. Nouvelle Notion API Stream :
- C’est une interface paramétrée.
- Des interfaces pour les primitifs (IntStream..)
- Ne porte pas de donnée mais elle est
connectée à une source.
- Ne peut pas modifier sa source (//)
- Elle traite les opérations de façon lazy il va
falloir donc distinguer les opérations.
Lambdas, Streams et Collectors

36. Lambdas, Streams et Collectors
Création d’un Stream :

37. API Stream applique les opérations en Lazy :
● Deux types d'opérations (JavaDoc)
○ Les Opérations Intermédiaires. ex. map, filter.
○ Les Opérations terminales : ex. reduce. (1X)
Lambdas, Streams et Collectors

38. Lambdas, Streams et Collectors
API Stream applique les opérations en Lazy :
Opérations Intermédiaires
Opérations Terminales

39. Lambdas, Streams et Collectors
API Stream Parallèle :
Les Streams rendent les
opérations sur une
collection déclaratives
on peux donc facilement
déléguer la // a la JVM.

40. Lambdas, Streams et Collectors
Pas si simple…...
Le Temps n’est pas meilleur
sur le traitement // la cause :
la méthode limit est statefull.

41. Retour sur mon projet exemple :
Implémenter le Pattern Map/Filter/Reduce sur
une collection pour calculer la sommes des
âges des personnes qui ont plus de 20 ans.
Lambdas, Streams et Collectors
Lambda simplifie l’écriture. Stream permet de rendre
déclaratif les opérations en
mode Lazy sur les
Collections
int sum = liste.stream()
.map(person -> person.getAge())
.filter(age -> age > 20)
.reduce((age1,age2) -> age1 + age2);
Réduction simple.

42. La Réduction simple :
Lambdas, Streams et Collectors
Pas de méthode sum() sur un
Stream paramétré.
Par contre le IntStream
possède cette méthode.

43. La Réduction Élément neutre :
Lambdas, Streams et Collectors
Et si l’ensemble est vide ? Éléments neutre d’une Réduction est la
valeur retourné si l’ensemble est vide
Pour le sum c’est simple,
une valeur neutre d’une
somme d’un élément vide
est 0.
Pour le max ou le min
alors ? ben il n’existe
pas d'élément neutre
satisfaisant.

44. La Réduction Élément neutre le type Optional :
Lambdas, Streams et Collectors
C’est une manière de rendre la
main au développeur sur un
code déclaratif quand le
programme ne peut pas
déduire une valeur.

45. La Réduction Élément neutre le type Optional :
Lambdas, Streams et Collectors
Pattern pour gérer les types :
D’autre Types :
List < Personne > liste = new ArrayList<Personne>();
Optional<Integer> sum = liste.stream()
….. .sum();
System.out.println(sum);
=> // Pas de NullPointerException Optional.empty

46. Sur IntStream, LongStream….:
● average()
● sum().
● summaryStatistics()
La Réduction simple :
Lambdas, Streams et Collectors
Sur Stream < T > :
● reduce()
● anyMatch, allMatch, noneMatch.
● findFirst(), findAny()

47. Retour sur mon projet exemple :
Implémenter le Pattern Map/Filter/Reduce sur
une collection pour calculer la sommes des
âges des personnes qui ont plus de 20 ans.
Lambdas, Streams et Collectors

48. JDK 7 Pattern
MapReFilter/Reduce.
Lambdas, Streams et Collectors
//Implémentassions d’une
Liste Custom
//Implémenter
List Custom
//Classe anonyme
trés “verbeux”
//Pattern Iterator Impératif

49. Lambdas, Streams et Collectors
int sum = liste.map(personne -> personne.getAge())
.filter(age -> age> 20)
.reduce((age1, age2) -> age1 + age2);
JDK 8 Pattern MapReFilter/Reduce.
- Utiliser des Expressions Lambdas.

50. - Utiliser les Interfaces du JDK8.
- Pattern Iterator et Imperatif.
- Pas de Lazy Operations.
- Réduction impérative.
Lambdas, Streams et Collectors
JDK 8 Pattern MapReFilter/Reduce.

51. Lambdas, Streams et Collectors
int sum = liste.stream()
.mapToInt(person -> person.getAge())
.filter(age -> age > 20)
.sum();
JDK 8 Pattern MapReFilter/Reduce.
- Utiliser des Expressions Lambdas.
- Utiliser l’API Stream.
- Utiliser la réduction Simple.

52. ● Réduction Mutable et l’API Collectors.
L’API Collectors est une boite à outils avec une
liste de réduction sur étagères. 37 Méthodes.
Les Réductions de l’API Collectors sont dit
mutables, elles définissent trois choses :
- Création du container.
- Comment ajouter un élément au container.
- Comment “merger” deux container en mode //.
Lambdas, Streams et Collectors

53. Lambdas, Streams et Collectors

54. Lambdas, Streams et Collectors
Réduction Mutable et l’API Collectors.

55. Lambdas, Streams et Collectors
La Méthode Mapping et l’introduction au downstream.
Réduction Mutable et l’API Collectors.
Une Fonction qui “map”
les éléments du Stream.
Downstream, un
“Collector” à appliqué aux
valeurs résultat du map…
(Chaînage possible)

56. Lambdas, Streams et Collectors
La Méthode groupingBy construit des tables de Hashage.
Réduction Mutable et l’API Collectors.
Le Mapper pour faire la clé
Downstream, l’opération à
appliquer sur les valeurs.

57. Lambdas, Streams et Collectors
La Méthode groupingBy construit des tables de Hashage.
Réduction Mutable et l’API Collectors.

58. Les Nouveautés Java 8
API Date java.util.time (JSR 310)
● La Nouvelle API est inspiré de la librairie java Joda-Time.
● Le But est de pallier aux défauts de Date et Calendar.
○ Immutabilité et Thread Safe.
○ Chaînage.
○ le mois "0" n'existe plus et le mois "1" correspond au mois de janvier.
○ Deux nouvelles notions de temps :
■ .Temps machine (un entier qui augmente depuis le 01/01/1970)
■ Temps humain (succession de champs ayant une unités année,
mois, jours, heures…)
○ Introduction de nouvelles notions Période, Instant, Durée.
Instant
Duration
ZonedDateTime
OffsetDateTime
LocalDateTime
Period
Intéropérabilité
TemporalAdjuter

59. Les Nouveautés Java 8
String en bref…..
String s = “bonjour”
IntStream s = s.chars(). map(String::toUpperCase).
forEach(System.out::print);
StringJoiner sj = new StringJoiner(",", “{“,”}”);
System.out.println(sj.add("one").add("two").
toString()); > {one,twho, three}

60. Les Nouveautés Java 8
Nio en bref…..
Stream < String > stream = Files.lines(path).filter(line -
> line.contains(“ERROR”) .findFirst()
.ifPresent(System.out::println); //AutoCloseable
//retourne les fichiers du répertoire.
Stream < Path > stream = Files.list(path);
//retourne les fichiers du sous arbre, profondeur.
Stream < Path > stream = Files.walk(path, 2);

61. Les Nouveautés Java 8
Et Encore….
“Api Concurrentes” => Stamped Lock, Concurrent Adders (Atomics)….
“Array.sort, Array.paralleSort” => Tri paralléle.
“Java Advanced Management Console” => Permettre de
contrôler la version de Java installés sur un Parck Informatique (Administrateur)
“MSI Enterprise JRE Installer” => Permettre l’installation et la
maintenance des JRE sur un parc informatique.
“Nashorm” => Nouveau moteur Javascript intégré dans le JDK (Quid du
Javascript coté serveur…)
“JVM” => Optimisation de la gestion de la mémoire supréssion du PermGen.

62. Fin, Merci, des Questions ?
L'horizon Java 8