Une introduction rapide à Java 8 Lambdas

Si vous êtes un programmeur Java et que vous souhaitez en savoir plus sur les lambdas Java 8, dans cet article, nous allons examiner de plus près la syntaxe et l'utilisation de lambda.

Une expression lambda en Java est un moyen concis d'exprimer une méthode d'une classe dans une expression. Il a une liste de paramètres et un corps. Le corps peut être une expression unique ou un bloc. Il est couramment utilisé lorsqu'une implémentation d'une interface est requise. Ce besoin survient généralement lorsqu'une interface est requise comme argument pour invoquer une méthode.

Quelques expressions Lambda simples

Examinons quelques exemples simples d'expressions lambda.

Ce qui suit est une expression lambda qui accepte deux nombres x et y et calcule la somme.

(int x,int y) -> x + y ; 
  

Supprimez les types de paramètres pour une représentation plus concise :

(x, y) -> x + y ; 
  

Définissez une fonction qui n'accepte aucun paramètre :

() -> 404 ; 
  

Ce qui suit est également valide, qui n'accepte aucun paramètre et ne renvoie rien :

() -> {} 
  

Pas besoin de parenthèses entourant les paramètres pour un seul paramètre :

x -> x + 1 
  

Des blocs de code plus complexes sont également possibles. Le lambda suivant accepte une seule ligne paramètre et effectue un traitement dessus. Notez que le type du paramètre est déduit du contexte environnant :

ligne -> { 
 Chaîne[] x =motif.split(ligne); 
 renvoie un nouveau joueur (Integer.parseInt (x [0]), 
 x[1], 
 x[2], 
 x[3], 
 Entier.parseInt(x[4])); 
 } 
  

Codage propre et concis

L'utilisation d'expressions lambda permet de rendre votre code propre et concis. Pour aider à cela, les classes Java 8 utilisent largement les lambdas.

Boucle sur une liste ou un ensemble

Classes de collection telles que List , Définir , file d'attente , et tels implémentent le Iterable interface qui rend la boucle sur les éléments beaucoup plus facile.

Déclarez une liste de noms.

List names =Arrays.asList("Joe", "Jack", "James", "Albert"); 
  

Boucle sur la liste sans lambda :

pour (nom de chaîne :noms) { 
 System.out.println(nom); 
 } 
  

En utilisant lambda, la boucle ci-dessus peut être écrite comme :

names.forEach(nom -> System.out.println(nom)); 
  

Avec les références de méthode Java 8, ce qui précède peut être écrit de manière encore plus concise comme :

names.forEach(System.out::println); 
  

Boucle sur une carte

Une carte est un mappage de clés à des valeurs. Boucler sur une carte implique de boucler sur chacun des mappages (clé, valeur). Comparez comment vous pouvez utiliser les lambdas pour cette situation.

Définissez d'abord une carte :

Map map =new HashMap<>(); 
 map.put("Atlanta, Géorgie", 110); 
 map.put("Austin, Texas", 115); 
 map.put("Baltimore, Maryland", 105); 
 map.put("Birmingham, Alabama", 99); 
 map.put("Boston, Massachusetts", 98); 
  

Vous pouvez boucler sur cette carte de manière traditionnelle :

for (Map.Entry e :map.entrySet()) { 
 System.out.println(e.getKey() + " => " + e.getValue()); 
 } 
  

Voici comment vous pouvez faire la même chose de manière rapide et concise en utilisant les lambdas :

map.forEach((k, v) -> System.out.println(k + " => " + v)); 
  

Interfaces fonctionnelles

Quel est le type de retour d'une expression lambda ? En d'autres termes, quel est le type de X dans la déclaration suivante ?

X x =a -> a + 1; 
  

Le type de retour d'une expression lambda est une interface fonctionnelle - une interface avec une seule méthode abstraite. Vous pouvez attribuer une expression lambda à une interface avec une méthode abstraite compatible. Quelques exemples ci-dessous.

Création d'une tâche multithread

Envisagez de créer une tâche à exécuter dans un thread séparé - vous devez définir la tâche comme Runnable interface et implémentez le run() méthode. Ici Runnable est une interface fonctionnelle.

la classe MyTask implémente Runnable { 
 ... 
 public void run() { 
 // implémentez votre tâche ici 
 System.out.println("En cours d'exécution dans un thread séparé maintenant."); 
 } 
 ... 
 } 
  

Vous pouvez ensuite créer une instance de MyTask class et l'utiliser pour démarrer un nouveau thread d'exécution.

Tâche MyTask =new MyTask(); 
 Thread thread =new Thread(task); 
 thread.start(); 
  

À l'aide d'un lambda, le processus de création d'un Runnable devient beaucoup plus facile. La définition de tâche ci-dessus peut être réécrite comme :

Tâche exécutable =() -> System.out.println("En cours d'exécution dans un thread séparé maintenant."); 
  

Ou encore :

Thread thread =new Thread(() -> System.out.println("En cours d'exécution dans un thread séparé maintenant.")); 
 thread.start(); 
  

Comparaison à l'aide d'un comparateur

Le comparateur est une interface fonctionnelle de comparaison d'objets d'un type donné. Il définit une seule méthode abstraite appelée compare() qui peut être défini à l'aide d'une expression lambda.

Voici une expression lambda créant un comparateur utilisé pour comparer les chaînes sans tenir compte de la casse.

Comparateur cmp =(x, y) -> x.compareToIgnoreCase(y); 
  

Une fois une instance du comparateur interface fonctionnelle a été créée, elle peut être réutilisée selon les besoins.

Ici, nous trions une liste de chaînes par ordre croissant.

List names =Arrays.asList("Joe", "Jack", "James", "Albert"); 
 Collections.sort(noms, cmp); 
 noms.forEach(System.out::println); 
 // imprime 
 Albert 
 Jack 
 James 
 Jo 
  

La liste ci-dessus est triée sur place. Nous pouvons maintenant le rechercher en utilisant binarySearch() méthode comme suit :

System.out.println("search(Joe):" + Collections.binarySearch(names, "Joe", cmp)); 
 # impressions 
 recherche(Joe):3 
  

Le calcul du maximum et du minimum à partir d'une liste est également facile à l'aide de lambdas.

Définissez quelques données :

Liste temps =Arrays.asList(110, 115, 105, 99, 98, 54, 109, 84, 81, 66, 72, 135, 115, 75, 82, 90, 88); 
  

Utilisez une expression lambda pour définir le comparateur :

Comparator cmpTemp =(x, y) -> Integer.compare(x, y); 
  

Et imprimez le maximum et le minimum :

System.out.println("------ Max/Min ------"); 
 System.out.println(Collections.max(temps, cmpTemp) + "/" + Collections.min(temps, cmpTemp)); 
  

Utiliser dans la programmation GUI

Les expressions lambda sont également extrêmement utiles dans la programmation d'interface graphique pour implémenter des gestionnaires d'événements. Voici un exemple d'utilisation d'un gestionnaire de clic de bouton.

Bouton JButton =new JButton("Click Me"); 
 button.addActionListener(e -> System.out.println("Bouton cliqué!")); 
  

Et c'était un aperçu rapide de l'utilisation des lambdas dans Java 8.

Les lambdas vous facilitent-ils la vie depuis Java 8 ? Veuillez expliquer dans les commentaires ci-dessous.

[]