Publicité

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 une manière concise 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 un seul expression ou un bloc 10 concepts Java de base que vous devez apprendre lors de la mise en routeQue vous écriviez une interface graphique, développiez un logiciel côté serveur ou une application mobile utilisant Android, l'apprentissage de Java vous sera très utile. Voici quelques concepts Java de base pour vous aider à démarrer. Lire la suite . 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 appeler une méthode.

Quelques expressions lambda simples

Voyons 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 enfermant des paramètres pour un seul paramètre:

x -> x + 1.

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

ligne -> { String [] x = pattern.split (ligne); retourne un nouveau joueur (Integer.parseInt (x [0]), x [1], x [2], x [3], Integer.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 collecte telles que liste, Ensemble, Queue, et ainsi mettre en œuvre le Iterable interface qui facilite le bouclage sur les éléments.

Déclarez une liste de noms.

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

Parcourez la liste sans lambda:

for (String name: names) {System.out.println (name); }

En utilisant lambda, la boucle ci-dessus peut s'écrire:

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:

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

Faire une boucle sur une carte

UNE Carte est un mappage des clés aux valeurs. Le bouclage sur une carte implique de boucler sur chacun des mappages (clé, valeur). Comparez comment vous pouvez utiliser des lambdas pour cette situation.

Définissez d'abord une carte:

Carte 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 parcourir cette carte de manière traditionnelle:

pour (Carte. Entrée 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 des 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 un interface fonctionnelle - une interface avec une seule méthode abstraite. Vous pouvez affecter 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 pour exécution dans un thread séparé 4 méthodes pour écrire du code multi-thread en JavaDans cet article, nous comparons quelques options pour écrire du code multithread en Java, afin que vous puissiez mieux juger quelle option utiliser pour votre prochain projet Java. Lire la suite - vous devez définir la tâche comme Runnable interface et mettre en œuvre le courir() 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 la Ma tâche et l'utiliser pour démarrer un nouveau thread d'exécution.

Tâche MyTask = new MyTask (); Thread thread = nouveau Thread (tâche); 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 suit:

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

Ou même:

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 pour comparer des objets d'un type donné. Il définit une seule méthode abstraite appelée comparer() qui peut être définie à 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 qu'une instance de Comparateur l'interface fonctionnelle a été créée, elle peut être réutilisée au besoin.

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

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

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

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

Il est également facile de calculer le maximum et le minimum à partir d'une liste à 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:

Comparateur 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));

Utilisation dans la programmation GUI

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

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

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

Lambdas vous a-t-il facilité la vie depuis Java 8? Veuillez expliquer dans les commentaires ci-dessous.