Java 8: Démo des closures ou expressions lambdas (Part 1)

Java 8 release n'est pas encore sortie mais Netapsys vous propose de découvrir les expressions lambdas ou closures à travers quelques démos.

Bien évidemment nous avons utilisé la version BETA 1.8.0-ea de JDK 8.

Nous commençons par une bonne introduction qui sera enrichie de plusieurs démos.

Les closures ou expressions lambda est en réalité une implémentation anonyme de l'unique méthode abstraite de l'interface cible (appelée interface fonctionnelle).

Gardant à l'esprit que les closures est une implémentation concise de l'unique méthode abstraite de l'interface fonctionnelle.

Les nouveautés de Java 8 sont nombreuses, nous y reviendrons ci-dessous sur la définition des closures avec plus de précisions.

Nous concluons avec les bénéfices des closures.

Passons à la pratique.

L'expression lambda s'appuie sur la notion d'interface déclarant une seule méthode abstraite. Ce type de méthode est nommé SAM: Single Abstrat Method.

Nous insistons sur le mot abstraite car en java 8 les interfaces peuvent avoir d'autres méthodes ayant des implémentations par défaut.

Les interfaces ayant une seule méthode abstraite sont nommés functional interfaces ou interfaces fonctionnelles.

Quelques exemples typiques d'interfaces fonctionnelles: ActionListener, Runnable, Callable, FileFilter, Comparator...

Résumons, une interface qui a une seule méthode abstraite et plusieurs autres méthodes ayant des implémentations par défaut est une interface fonctionnelle.

Au passage, en Java 8 les interfaces pourraient déclarer des méthodes statiques ce qui rend obsolète les classes utilitaires.

Nous savons tous que l'un des inconvénients de Java est la prolifération des classes dès que l'on ajoute de nouvelles fonctionnalités.

C'est le cas d'application GUI (Swing), nombreuses classes anonymes sont écrites rien que pour définir le code de la seule méthode de l'interface ActionListener.

Or, avec les closures, le code sera plus concis et pas que ça...

En effet, le temps d'exécution sera mieux optimisé qu'avec le chargement par la JVM des classes anonymes.
Dans les versions Java 7 et antérieure, l'implémentation d'interface (ayant une seule méthode) se fait naturellement de deux façons:

  • Ecrire une nouvelle classe implémentant cette interface,
  • Ecrire une classe anonyme.

L'expression lambda est justement une implémentation des functional interfaces et cela sans ajouter des classes (anonymes ou non).

A noter que les expressions lambdas ne peuvent être utilisées qu'avec les interfaces fonctionnelles ayant donc une seule méthode abstraite.

L'intérêt majeur des expressions lambdas est de favoriser le support des architectures à processeur multi-cœur reliée avec des solutions de calcul parallèl.

Ainsi, on peut dire qu'une expression lambda est tout simplement un replacement judicieux des classes anonymes.

Voici en détail les étapes de mise en pratique:

ETAPE 1. Configurer l'environnement

ETAPE 2. Créer et configurer le projet java

ETAPE 3. Première démo et exemples

ETAPE 1.

  • Télécharger le JDK 8 ici.

Installer le jdk 8 en le dézippant.

A ce stade nul besoin de configurer les variables d'environnement.

  • En option, télécharger eclipse configuré pour java 8.

Noter que l'IDE eclipse doit être configuré ainsi:

Dans Windows >>> Préférences >>> Java >>> Installed JRE, indiquer le chemin du jdk 8 installé.

NOTE. Bien évidemment, un éditeur de texte et une console suffiront pour les démos si l'environnement est bien configuré.

ETAPE 2. Créer et configurer le projet java

Créer le projet java standard (ou projet Maven depuis l'archetype quickstart) avec l'IDE eclipse.
Ensuite cliquer droit sur le projet >>> Java >>> Compiler et positionner Compiler Compliance Level à 1.8 BETA.

Enfin, cliquer sur Apply.

Rappelons on peut utiliser les commandes maven à condition de configurer la variable d'environnement JAVA_HOME.
Pour cela il suffit de la setter vers jdk8 dans la console de lancement des commandes maven.

Aussi dans le pom du projet le plugin maven-compiler-plugin doit pointer vers java 1.8 (source et target).

ETAPE 3. Première démo et exemples d'expressions lambdas

Acte 3.1. Ecrire une interface fonctionnelle

Cette interface sera nommée IAffichage :

public interface IAffichage {
    void affiche(String msg);
}

Acte 3.2. Ecrire une classe (interface) utilitaire

Écrivons une interface, nommée Displayer, qui va consommer l'interface IAffichage.

public interface Displayer {

	public static void display(IAffichage aff){
		aff.afficher();

          //....etc
	}

}

Noter que la méthode statique display prend en argument l'interface fonctionnelle IAffichage.

A l'étape suivante nous testons cette méthode en créant une expression lambda implémentant IAffichage.

Acte 3.3. Ecrire un test unitaire

public class TestAffichageExpLambda {

@Test public void test() {		
 IAffichage aff=()->System.out.println("Hello lambdas expressions!");
 Displayer.display ( aff );
 }
}

Ou pour faire encore plus concis, on pourrait écrire ceci:

public class TestAffichageExpLambda {
@Test public void test() {	
  Displayer.display (
   ()->System.out.println("Hello lambdas expressions!") );
}
}

La sortie de l'exécution affiche la ligne:
Hello lambdas expressions!

SYNTAXE GENERALE D'EXPRESSION LAMBDA

La syntaxe générale d'une expression lambda est comme suit:

( formal parameter list ) -> { expression or statements }

Exemple 1:

La méthode de l'interface IAffichage ne prend pas d'argument alors pour définir une expression lambda on place une parenthèse vide () comme suit:

IAffichage aff=()->System.out.println("Hello...");

EXPRESSION LAMBDA EST UNE METHODE ANONYME

Une expression lambda est en fait une implémentation anonyme de la seule méthode de l'interface fonctionnelle ciblée.

Elle doit être compatible avec l'unique méthode de l'interface fonctionnelle (argument et valeur de retour).

La signature de l'expression lambda doit être identique à celle de l'unique méthode de l'interface.

L'expression lambda peut lever les exceptions qui sont déclarées dans la signature de la méthode de l'interface fonctionnelle.

Enfin, la cible de l'expression lambda est une interface fonctionnelle dont le type est déterminé selon le contexte.

EXEMPLES D'EXPRESSIONS LAMBDAS

Ci-après des exemples d'expressions lambdas pour différentes interfaces fonctionnelles:

Exemple 2:

Soit l'interface IUser :

interface IUser{
   boolean login ( String id,String pwd);
} 

L'expression lambda ciblant cette interface s'écrit comme suit:

IUser u = (String id,String pwd)-> true;

ou encore:

IUser u=(String id,String pwd)->id.equals("root") && pwd.equals("root");

Ou plus lisible peut-être:

IUser u=(String id,String pwd)-> verif(id,pwd);

verif(String id,String pwd) est une méthode qui renvoie un boolean.

Plusieurs questions restent sans réponses, nous approfondissons prochainement notre connaissance des expressions lambdas permettant d'entrevoir l'intérêt.

sources: http://www.oracle.com/technetwork/articles/java/lambda-1984522.html

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Captcha *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.