Utiliser efficacement les expressions Lambda en Java

L'expression Lambda est une fonctionnalité importante introduite dans Java8, qui peut simplifier le processus d'écriture de code et améliorer l'efficacité de l'exécution du code. Cet article explique comment utiliser efficacement les expressions Lambda en Java.

1. Comprendre la syntaxe de l'expression Lambda

L'expression Lambda se compose de trois parties : la liste des paramètres, le symbole de la flèche et le corps de la fonction.

Vous trouverez ci-dessous un exemple simple d'expression Lambda qui ajoute deux paramètres.

(a, b) -> a + b

où la liste des paramètres est a et b, et le symbole de flèche "->" signifie ajouter les paramètres a et b et renvoyer le résultat. Il s'agit d'une simple expression Lambda, mais elle peut remplacer la manière générale d'écrire des fonctions et améliorer l'efficacité du code.

2. Utilisez des expressions Lambda pour simplifier le code

Au quotidien, vous pouvez utiliser des expressions Lambda pour simplifier le code. Par exemple, utilisez des expressions Lambda au lieu de classes anonymes pour implémenter des interfaces.

Code original :

button.addActionListener(new ActionListener() {

@Override
public void actionPerformed(ActionEvent e) {
    System.out.println("Button clicked!");
}

});

Après avoir utilisé l'expression Lambda :

button.addActionListener(e -> System.out.println("Bouton cliqué ! " ));

En utilisant les expressions Lambda, le code peut être plus concis et lisible.

3. Utilisez des expressions Lambda pour implémenter des interfaces fonctionnelles

Le scénario d'application le plus important des expressions Lambda est d'implémenter des interfaces fonctionnelles. L'interface fonctionnelle est une interface avec une seule méthode abstraite. Grâce aux expressions Lambda, il est facile d'implémenter cette interface et de transmettre des blocs de code en paramètres. Ce qui suit est une interface fonctionnelle simple et son implémentation :

interface Operation {

int operate(int a, int b);

}

Operation add = (a, b) -> a + b;

int result = add.operate(2, 3 ) ;

En implémentant l'interface Operation et en passant l'expression Lambda correspondante, la forme de programmation fonctionnelle peut être simplifiée en un ensemble d'objets fonction. Cela rend le code plus modulaire et plus lisible.

4. Utiliser des références de méthode

Les expressions Lambda peuvent non seulement remplacer les classes anonymes, mais peuvent également être utilisées avec des références de méthode. Les références de méthodes font référence à une manière plus courte et plus claire de représenter les expressions Lambda.

Ce qui suit est une expression Lambda simple et sa référence de méthode.

Expression Lambda :

List strList = new ArrayList<>();
strList.forEach((String s) -> System.out.println(s));

Référence de la méthode :

List strList = new ArrayList<>();
strList.forEach(System.out::println);

Dans cet exemple, modifiez l'expression Lambda "(String s) -> System.out .println (s)" est remplacée par la référence de méthode "System.out::println".

Les références de méthodes peuvent améliorer la lisibilité et la maintenabilité du code dans le contexte de l'optimisation des expressions Lambda.

5. Utilisez des expressions Lambda en combinaison avec l'API Stream

Les expressions Lambda ont également des applications importantes dans l'API Stream. L'API Stream offre un moyen efficace et intuitif de traiter les données en streaming. Vous pouvez utiliser des expressions Lambda pour implémenter certaines opérations courantes via l'API Stream, telles que le filtrage, le mappage, le regroupement et les statistiques.

Vous trouverez ci-dessous un exemple simple utilisant des expressions Lambda et l'API Stream.

List numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int sum = numList.stream()

            .filter(n -> n > 5)
            .mapToInt(Integer::intValue)
            .sum();

Dans cet exemple, First utilisez l'API Stream pour convertir la liste en flux, puis utilisez filter() et mapToInt() des expressions Lambda pour filtrer et mapper les éléments. Enfin, utilisez la méthode sum() pour calculer la somme des éléments qui remplissent les conditions.

À l'aide des références de méthodes et de l'API Stream, vous pouvez compresser le code au minimum et améliorer la lisibilité et la maintenabilité du code.

Conclusion

Les expressions Lambda sont une fonctionnalité très utile introduite dans Java8. L'utilisation d'expressions Lambda peut réduire considérablement la redondance et la complexité du code, rendant le programme plus concis et plus lisible. Lors de l’écriture de code Java, il est très important de maîtriser les expressions Lambda. Cet article fournit des conseils et des exemples utiles qui, nous l’espérons, seront utiles aux lecteurs.

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!