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.


Design Pattern Iterator

Programmation Impérative, verbeux


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


JDK 7 Un langage Impératif, verbeux

JDK 8 Un langage Déclaratif + lisible

JDK8 (Lambdas, Stream et Collector)


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.


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.


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 :


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 CollectorsAvec un peu d'entraînement le code deviens plus lisible :

Encore plus simple le type de paramètre implicite :


- Possède 1 méthode.- Annotation

@FunctionnalInterface pas obligatoire mais permet de valider les interfaces à la compilation.


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.



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.


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.



int sum = liste.map(personne -> personne.getAge()) .filter(age -> age> 20) .reduce((age1, age2) -> age1 + age2);


- 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.




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”


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


- 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.



- - Erreur de Compilation (dans l’IDE)



- La Classe Gagne



- Le plus spécifique gagne !


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 :




int sum = liste.stream.map(personne -> personne.getAge())

.filter(age -> age> 20) .reduce((age1, age2) -> age1 + age2);


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.



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)



API Stream applique les opérations en Lazy :

Opérations Intermédiaires

Opérations Terminales


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.


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


Implémenter le Pattern Map/Filter/Reduce sur une collection pour calculer la sommes des âges des personnes qui ont plus de 20 ans.


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 :


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 :


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 :


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 :


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 :


Sur Stream < T > : ● reduce()● anyMatch, allMatch, noneMatch.● findFirst(), findAny()


Implémenter le Pattern Map/Filter/Reduce sur une collection pour calculer la sommes des âges des personnes qui ont plus de 20 ans.





- 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.


int sum = liste.stream() .mapToInt(person -> person.getAge()) .filter(age -> age > 20) .sum();


- 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 CollectorsRéduction Mutable et l’API 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)


La Méthode groupingBy construit des tables de Hashage.


Le Mapper pour faire la clé

Downstream, l’opération à appliquer sur les valeurs.


La Méthode groupingBy construit des tables de Hashage.


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

techday arrow group: java 8

Technology