Download - Techday Arrow Group: Java 8
Java 8
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”
Qui suis-je ?
Stéphane GoumardConsultant Java.
Arrow Group
#Big Data
#Spark
#Hadoop
#Java#Architecture#Dev
#NoSql
#Spring #EAI
@José Paumard Université Paris13@Remi Forax Université Paris13
#Scub Foundation@sgoumard
Lambdas, Streams et Collectors
- Pattern Iterator.
GOF (Gang Of Four)
- Lambdas (JSR 335) Introduction par l’exemple.
Lambdas, Streams et Collectors
Design Pattern Iterator
Programmation Impérative, verbeux
Lambdas, Streams et Collectors
Un langage déclaratif le SQL…..
select sum(age)from Personwhere age > 20
On Décrit le Résultat
Les détails d'exécutions sont à la charge du SGBD
Lambdas, Streams et Collectors
JDK 7 Un langage Impératif, verbeux
JDK 8 Un langage Déclaratif + lisible
JDK8 (Lambdas, Stream et Collector)
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 ReducePattern Map/Filter/Reduce
JDK 7 Pattern MapReFilter/Reduce.
Lambdas, Streams et Collectors//Implémentassions d’une Liste Custom
//Implémenter List Custom
//Classe anonymetrés “verbeux”
//Pattern Iterator Impératif
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.
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
Lambdas, Streams et CollectorsPlus d’une ligne de Code :
Type de retour de méthode void :
Prends plus d’un argument :
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”
Pour le moment :
Une expression lambda et une autre façon plus lisible d’écrire des instances de classes anonymes.
Lambdas, Streams et Collectors
Lambdas, Streams et CollectorsAvec un peu d'entraînement le code deviens plus lisible :
Encore plus simple le type de paramètre implicite :
Lambdas, Streams et Collectors
- Possède 1 méthode.- Annotation
@FunctionnalInterface pas obligatoire mais permet de valider les interfaces à la compilation.
Lambdas, Streams et Collectors
Une expression lambda n’est pas un objet elle a pas une identité propre.
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
Lambdas, Streams et Collectors
Un Supplier fournit un objet
Un Consumer consomme un objet
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
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
JDK 7 Pattern MapReFilter/Reduce.
Lambdas, Streams et Collectors//Implémentassions d’une Liste Custom
//Implémenter List Custom
//Classe anonymetrés “verbeux”
//Pattern Iterator Impératif
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.
- Utiliser les Interfaces du JDK8.- Pattern Iterator et Imperatif.- Pas de Lazy Operations. /
allMatch- Réduction impérative.
Lambdas, Streams et CollectorsJDK 8 Pattern MapReFilter/Reduce.
É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
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”
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 !
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.
Lambdas, Streams et Collectors
Interfaces par défaut Java 8
- - Erreur de Compilation (dans l’IDE)
Lambdas, Streams et Collectors
Interfaces par défaut Java 8
- La Classe Gagne
Lambdas, Streams et Collectors
Interfaces par défaut Java 8
- Le plus spécifique gagne !
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.
É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
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
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
Lambdas, Streams et Collectors
Création d’un Stream :
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
Lambdas, Streams et Collectors
API Stream applique les opérations en Lazy :
Opérations Intermédiaires
Opérations Terminales
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.
Lambdas, Streams et Collectors
Pas si simple…...Le Temps n’est pas meilleur sur le traitement // la cause : la méthode limit est statefull.
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.
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.
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.
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.
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
Sur IntStream, LongStream….: ● average()● sum().● summaryStatistics()
La Réduction simple :
Lambdas, Streams et Collectors
Sur Stream < T > : ● reduce()● anyMatch, allMatch, noneMatch.● findFirst(), findAny()
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
JDK 7 Pattern MapReFilter/Reduce.
Lambdas, Streams et Collectors//Implémentassions d’une Liste Custom
//Implémenter List Custom
//Classe anonymetrés “verbeux”
//Pattern Iterator Impératif
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.
- Utiliser les Interfaces du JDK8.- Pattern Iterator et Imperatif.- Pas de Lazy Operations.- Réduction impérative.
Lambdas, Streams et CollectorsJDK 8 Pattern MapReFilter/Reduce.
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.
● 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
Lambdas, Streams et Collectors
Lambdas, Streams et CollectorsRéduction Mutable et l’API Collectors.
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)
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.
Lambdas, Streams et Collectors
La Méthode groupingBy construit des tables de Hashage.
Réduction Mutable et l’API Collectors.
Les Nouveautés Java 8API 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
LocalDateTimePeriod
Intéropérabilité
TemporalAdjuter
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}
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);
Les Nouveautés Java 8Et 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.
……………………………...
Fin, Merci, des Questions ?
L'horizon Java 8