JAVA 8

JAVA 8
EST-IL TOUJOURS
UN LANGAGE
ACTUEL ?
AVIS D’EXPERTS

2
SOMMAIRE
Qui est l’auteur ? ...................................................................................................................................................... 3
Introduction ............................................................................................................................................................. 4
Du projet Oak à Java 8 ................................................................................................................................. 4
L’introduction des lambdas : quel impact ? .............................................................................................. 5
Le pattern Iterator ........................................................................................................................................ 6
Premières expressions lambdas ........................................................................................................................... 7
Une première expression lambda ............................................................................................................. 7
Construction d’une expression lambda .................................................................................................... 7
Un peu plus de détails ................................................................................................................................. 8
Que faire des lambdas ? .............................................................................................................................. 9
Map / Filter / Reduce ............................................................................................................................................... 9
Introduction .................................................................................................................................................. 9
Paralléliser ses traitements ....................................................................................................................... 10
Mapper et filtrer en parallèle .................................................................................................................... 11
Réduire en parallèle ................................................................................................................................... 12
Optimisation des réductions .................................................................................................................... 12
API Stream .............................................................................................................................................................. 13
Un nouveau concept dans le JDK ............................................................................................................. 13
Construction d’un Stream ......................................................................................................................... 14
Opérations sur un Stream ......................................................................................................................... 14
Exécution en parallèle ............................................................................................................................... 15
La réduction ........................................................................................................................................................... 15
Deux types de réduction ........................................................................................................................... 15
Exemples de réductions ............................................................................................................................ 16
Utilisation de collectors ............................................................................................................................. 17
Java 8 : une version pour l’avenir ........................................................................................................................ 19
Pourquoi les lambdas ? ............................................................................................................................. 19
Une version toujours compatible ............................................................................................................. 19
Migrer vers Java 8 ....................................................................................................................................... 19
En bref .......................................................................................................................................................... 20

3
Qui est l’auteur ?
José Paumard
Formateur & expert Java / Java EE
Passionné par la programmation des ordinateurs depuis plus de 20 ans,
José a fait ses premières armes en assembleur, puis C, C parallèle sur
machine SIMD avant d’adopter Java comme langage objet,
indispensable à la plupart des grandes applications modernes.
Il apporte son expertise et sa capacité d’analyse et de synthèse à
nombre de projets, principalement sur les couches basses, proches des
données, mais aussi sur la conception d’IHM complexes, natives ou
dans le navigateur.
José sait, depuis 20 ans, rester en prise avec des technologies qui
évoluent à la vitesse que l’on sait.
Maître de conférences depuis 15 ans, José se passionne également pour
l’éducation et la transmission des connaissances. Il tient un blog, Java le
soir, source documentaire francophone sur les technologies Java pour
des milliers de développeurs dans le monde.

4
Introduction
Du projet Oak à Java 8
Java est un langage conçu dans la première moitié des années 90, il y a donc environ 25 ans, sous le nom
de « projet oak ». La première idée des équipes qui conçoivent ce nouveau langage est qu’il soit portable.
Non pas portable au sens du C, que l’on peut compiler sans modification du code source sur tous les OS,
(même si la réalité des choses est un peu plus problématique), mais au sens où un code Java déjà compilé
peut s’exécuter n’importe où. Leur objectif annoncé est de proposer cette technologie aux câblo-
opérateurs américains, qui pourront ainsi déployer leurs applications sur les nombreux modèles de
décodeurs dont ils équipent leurs clients. Et effectivement, les premières versions expérimentales de
Java fonctionnent sur une set top box graphique, qui exhibe un petit personnage triangulaire blanc et noir
au nez rouge, devenu la fameuse mascotte Duke. Cette utilisation de Java viendra, mais beaucoup plus
tard.
Son succès industriel ne vient pas immédiatement, aussi du fait que les premières versions diffusées
sont encore probablement un peu expérimentales. La première version réellement utilisable est la 2,
sortie en 1998, il y a donc 16 ans. Durant ces 16 dernières années, les versions se succèdent jusqu’à la 8,
sortie le 18 mars 2014.
Sun réussit à maintenir un rythme de sortie d’environ une version majeure tous les deux ans. Et puis à
la version 6 en 2006, l’annonce du rachat de Sun par Oracle vient perturber les choses.
Au premier degré, le rachat perturbe le rythme des sorties : la version 7 ne sort qu’en 2011, soit après
cinq longues années d’attente. Techniquement la période n’est pas la bonne : en 2005 le débat
« comment intégrer les lambdas expressions » en Java s’ouvre. La question n’est pas d’intégrer ou non
cette technologie, mais porte bien sur le comment. Le délai dans la sortie de la version 7 met en sommeil
ce débat, et cette intégration également. Rétrospectivement, ce retard n’est peut-être pas une si
mauvaise chose, cela aura probablement permis de ne pas tomber dans certains écueils.
Le rachat perturbe aussi les esprits. Sun microsystems jouit depuis longtemps d’une excellente image
auprès des développeurs open source. Aux débuts de Java, c’est Sun qui permet de conclure les
développements de la première JVM disponible sur Linux, au travers du projet Blackdown. Linux est
encore un système émergent à cette époque, et n’est pas dans la liste des OS officiellement supportés.
Oracle ne jouit pas de cette image. Le fait qu’il se retrouve propriétaire de Java provoque plutôt la
défiance de la part de cette communauté, un peu turbulente, il est vrai. D’autant que les premières
décisions d’Oracle vis-à-vis du JCP, instance qui gouverne les évolutions de Java, ne vont pas dans le sens

5
attendu. On se rappelle du départ tonitruant de Doug Lea, professeur à State University of New York à
Oswego, éminent spécialiste de la programmation concurrente, et auteur des principales API Java dans
ce domaine.
En 2010, Oracle se retrouve donc avec un problème à résoudre : quelle sera la prochaine version majeure
de Java ? Et surtout : que mettra-t-on dans cette version ? Voilà quatre ans qu’il n’y a pas eu de version
majeure, le projet Lambda est dans l’ornière, et les rumeurs commencent à courir : « Java est en train de
devenir le nouveau Cobol », c’est-à-dire un langage du passé, condamné à disparaître à plus ou moins
long terme.
La réponse d’Oracle a été de sortir une version 7, avec ce qui était alors prêt à être publié. Donc une
version 7 sans le projet Lambda. Cette version contient malgré tout de nombreux ajouts très
intéressants : quelques modifications du langage, des mises à jour des API existantes, une nouvelle API
I/O, un framework de calcul parallèle. Mais l’attente est déçue : les lambdas sont reportés pour la version
8, plus tard. La réaction de la blogosphère est lapidaire : Java 7 sans les lambdas déçoit.
Un deuxième événement vient perturber les choses. 2012 devait être l’année de l’intégration du projet
Lambda dans Java 8. Elle sera l’année de la correction de problèmes de sécurité dans Java 6 et 7. Ces
problèmes arrivent jusque dans la presse grand public, l’image de Java est atteinte, et Oracle doit
consacrer toutes les ressources disponibles aux correctifs. Java 8 prend du retard, la date de sortie
annoncée est repoussée de 6 mois.
C’est donc en 2014 que Java 8 sort. On peut considérer que l’intégration du projet Lambda, initialement
prévue probablement pour 2008 a donc pris 6 ans de retard. Considérable pour un langage informatique.
L’introduction des lambdas : quel impact ?
En 1998, le JDK de Java 2 compte environ 1500 classes. Pour Java 4, dernière version avant les génériques,
ce total s’élève à 2 700 classes. Java 5 voit arriver les génériques, modification majeure du langage, et
compte environ 3 300 classes. Java 6, dernière version publiée par Sun microsystems, compte 3500
classes. En 8 ans, le nombre de classes du JDK augmente donc, le langage subit une modification majeure.
La JVM, elle, ne change pas, en tout cas pas dans la façon dont elle exécute le code Java. Le bytecode Java
ne change pas pendant plus de 10 ans.
Java 7 est une rupture de ce point de vue. Le langage évolue un peu (sans grande révolution toutefois),
le nombre de classes passe à 7400, et une nouvelle instruction de bytecode est introduite. Cette
augmentation du volume de l’API en fait l’une des plus grosses mises à jour du JDK.