Comment utiliser Java Lambdas et les interfaces fonctionnelles?

Cet article explique Java Lambdas - Concise les fonctions anonymes - et leur utilisation avec des interfaces fonctionnelles (interfaces avec une méthode abstraite). Il détaille la syntaxe de Lambda, les contraste avec des classes intérieures anonymes mettant en évidence la brièveté et la lisibilité

Comment utiliser Java Lambdas et Interfaces fonctionnelles

Les Lambdas Java sont des fonctions anonymes concises qui fournissent un paradigme de programmation fonctionnelle dans Java. Ce sont essentiellement des blocs de code qui peuvent être transmis comme arguments aux méthodes ou stockés en variables. Pour les utiliser, vous avez besoin d'une interface fonctionnelle , qui est une interface avec exactement une méthode abstraite (bien qu'elle puisse avoir plusieurs méthodes par défaut ou méthodes statiques). La signature de l'expression de Lambda correspond implicitement à la méthode abstraite de l'interface fonctionnelle.

Voici un exemple simple en utilisant l'interface Runnable (une interface fonctionnelle intégrée):

 <code class="java">Runnable myRunnable = () -> System.out.println("Hello from a lambda!"); new Thread(myRunnable).start();</code>

Ce code crée une expression lambda () -> System.out.println("Hello from a lambda!"); qui implémente la méthode run() de l'interface Runnable . Les parenthèses vides () indiquent que la Lambda ne prend aucun argument. La flèche -> sépare la liste des paramètres du corps.

Un autre exemple utilisant une lambda avec paramètres:

 <code class="java">interface StringOperation { String operate(String str); } StringOperation reverseString = (str) -> new StringBuilder(str).reverse().toString(); String reversed = reverseString.operate("hello"); // reversed will be "olleh"</code>

Ici, StringOperation est une interface fonctionnelle. LA LAMBDA Expression (str) -> new StringBuilder(str).reverse().toString() prend un argument String ( str ) et renvoie une String inversée.

Avantages de Java Lambdas sur les classes intérieures anonymes

Les classes intérieures anonymes, tout en atteignant des fonctionnalités similaires, sont beaucoup plus verbeuses que les lambdas. L'utilisation de Lambdas offre plusieurs avantages clés:

• Brivity: les lambdas sont beaucoup plus concises, conduisant à un code plus propre et plus lisible. Cela réduit la quantité de code de passe-partout requise.
• Amélioration de la lisibilité: la syntaxe concise des lambdas rend le code plus facile à comprendre et à maintenir. La logique principale est immédiatement apparente, contrairement aux classes intérieures anonymes où la syntaxe peut masquer l'intention.
• Flexibilité améliorée: les lambdas peuvent être utilisés de manière plus flexible dans divers contextes, tels que les arguments de méthode, les valeurs de retour et les affectations variables. Les classes intérieures anonymes sont plus restreintes dans leur utilisation.
• Inférence de type: le compilateur déduit les types de paramètres lambda, réduisant le besoin de déclarations de type explicite. Cela simplifie le code et le rend moins sujet aux erreurs.

Considérez à nouveau l'exemple Runnable . L'équivalent de classe intérieure anonyme serait:

 <code class="java">Runnable myRunnable = new Runnable() { @Override public void run() { System.out.println("Hello from an anonymous inner class!"); } }; new Thread(myRunnable).start();</code>

Ceci est clairement plus long et moins expressif que la version lambda.

Création de vos propres interfaces fonctionnelles en Java

La création de votre propre interface fonctionnelle est simple. Définissez simplement une interface avec exactement une méthode abstraite. Vous pouvez ajouter des méthodes par défaut et des méthodes statiques au besoin. L'annotation @FunctionalInterface est facultative mais recommandée. Il aide le compilateur à appliquer la règle de la méthode abstraite unique et à attraper les erreurs tôt.

 <code class="java">@FunctionalInterface interface MyFunctionalInterface { int calculate(int a, int b); default int add(int a, int b){ return ab; } } // Usage MyFunctionalInterface myOperation = (a, b) -> a * b; int result = myOperation.calculate(5, 3); // result will be 15 int sum = myOperation.add(5,3); // result will be 8</code>

Dans cet exemple, MyFunctionalInterface est une interface fonctionnelle avec une méthode abstraite calculate() . L'annotation @FunctionalInterface l'indique. La méthode add() est une méthode par défaut.

Utilisation de Java Lambdas avec des bibliothèques et des frameworks existants

Les Lambdas Java sont largement pris en charge par de nombreuses bibliothèques et cadres Java existants. Ils sont intégrés dans les API Java de base et sont couramment utilisés avec:

• API Java Streams: L'API Streams s'appuie fortement sur les Lambdas pour le traitement efficacement des collections de données.
• Swing et Javafx: La gestion des événements dans ces cadres d'interface utilisateur peut être simplifié de manière significative à l'aide de lambdas.
• Spring Framework: Spring utilise largement les lambdas pour l'injection de dépendance, la manipulation des événements et d'autres aspects.
• De nombreuses autres bibliothèques: de nombreuses bibliothèques tierces intègrent des lambdas dans leurs API pour un code plus concis et fonctionnel.

Par exemple, en utilisant Lambdas avec l'API Streams:

 <code class="java">List<integer> numbers = Arrays.asList(1, 2, 3, 4, 5); int sum = numbers.stream().map(n -> n * 2).sum(); // sum will be 30</integer></code>

Ce code utilise un lambda n -> n * 2 dans le pipeline de flux pour doubler chaque numéro avant de les résumer. Il s'agit d'une approche beaucoup plus propre par rapport à l'utilisation de l'itération traditionnelle. L'adoption généralisée des lambdas en fait une partie essentielle du développement de Java moderne.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!