Une brève analyse des expressions Lambda dans Java 8 : Pourquoi utiliser des expressions Lambda ?

Le contenu de cet article concerne une brève analyse des expressions Lambda dans Java 8 : pourquoi les expressions Lambda doivent être utilisées. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Les expressions Lambda sont la fonctionnalité la plus populaire de Java8. Les gens ont introduit le concept de programmation fonctionnelle dans Java, un langage de programmation impératif entièrement orienté objet.

Quant au fonctionnement de la programmation fonctionnelle, ce sujet dépasse le cadre de cet article, mais nous allons extraire une de ses fonctionnalités qui est évidemment différente de la POO (Programmation Orientée Objet) dont nous parlons souvent.

Dans cet article, nous apprendrons ce que sont exactement les expressions lambda et comment elles s'intègrent dans l'écosystème Java global. Nous observerons et comparerons également le code qui n'utilise pas d'expressions lambda et l'exemple de code qui est refactorisé ultérieurement à l'aide de lambda.

Comprendre les expressions Lambda

Une expression Lambda est un morceau de code que nous pouvons transmettre et exécuter. Pour nous, programmeurs Java, nous n’avons pas l’habitude de passer un morceau de code dans une fonction. Notre habitude est d'encapsuler le code défini dans le corps de la méthode, puis de l'exécuter via la référence d'objet, comme indiqué ci-dessous :

public class LambdaDemo {
    public void printSomething(String something) {
        System.out.println(something);
    }
    public static void main(String[] args) {
        LambdaDemo demo = new LambdaDemo();
        String something = "I am learning Lambda";
        demo.printSomething(something);
    }
}

C'est un classique Le style du paradigme de développement POO qui cache l’implémentation de la méthode à l’appelant. L'appelant transmet simplement une variable à la méthode, puis la méthode effectue certaines opérations sur la variable et renvoie une autre valeur de variable ou, comme dans notre exemple, produit des effets secondaires.

Nous allons maintenant examiner une implémentation équivalente qui utilise le passage de comportement au lieu du passage de variables. Pour ce faire, nous devons créer une interface fonctionnelle qui définit le comportement plutôt que l'abstraction des méthodes. Une interface fonctionnelle est une interface avec une seule méthode :

public class LambdaDemo {
    interface Printer {
        void print(String val);
    }
    public void printSomething(String something, Printer printer) {
        printer.print(something);
    }
}

Dans l'implémentation du code ci-dessus, l'interface de l'imprimante est responsable de toutes les opérations d'impression. La méthode printSomething ne définit plus le comportement, mais exécute le comportement défini par Printer :

public static void main(String[] args) {
    LambdaDemo demo = new LambdaDemo();
    String something = "I am using a Functional interface";
    Printer printer = new Printer() {
        @Override
        public void print(String val) {
            System.out.println(val);
        }
    };
    demo.printSomething(something, printer);
}

Plus les lecteurs les plus observateurs l'ont peut-être remarqué, je ne le fais pas rien de nouveau ici. C'est vrai car je ne l'ai pas encore appliqué aux expressions lambda. Nous créons simplement une implémentation concrète de l’interface Printer et la transmettons à la méthode printSomething.

L'exemple ci-dessus vise à nous apporter un objectif clé de l'introduction des expressions Lambda dans Java :

Les expressions Lambda étaient à l'origine utilisées pour définir une implémentation en ligne d'une interface fonctionnelle

Avant nous reconstruisons l'exemple ci-dessus à l'aide d'expressions lambda, apprenons les connaissances syntaxiques nécessaires :

(param1,param2,param3...,paramN) - > {//代码块;}

Une expression lambda se compose d'une liste de paramètres entourée de parenthèses et séparée par des virgules, que nous définissons habituellement dans une déclaration de méthode, suivies d'une flèche pointant vers le code à exécuter. Maintenant, refactorisons le code ci-dessus en utilisant lambda :

public static void main(String[] args) {
    LambdaDemo demo = new LambdaDemo();
    String something = "I am learning Lambda";
    /**/
    Printer printer = (String toPrint)->{System.out.println(toPrint);};
    /**/
    demo.printSomething(something, printer);
}
}

Il a l'air très compact et beau. Étant donné que l'interface fonctionnelle ne déclare qu'une seule méthode, les paramètres passés dans la première partie du lambda sont automatiquement mappés à la liste des paramètres de la méthode et le code à droite de la flèche est considéré comme l'implémentation spécifique de la méthode.

Pourquoi utiliser les expressions Lambda

Comme dans l'exemple précédent, les expressions lambda nous permettent d'avoir un code plus compact, plus facile à lire et à suivre. Cette approche présente d'autres avantages en termes de performances et de traitement multicœur, mais ils ne s'appliquent qu'après avoir compris l'API Streams, ce qui dépasse le cadre de cet article.

En comparant la méthode main avec et sans lambda, lorsqu'elle raccourcit soudainement le code, on peut effectivement voir la puissance des expressions lambda :

public static void main(String[] args) {
    LambdaDemo demo = new LambdaDemo();
    String something = "I am learning Lambda";
    /**/
    Printer printer = (String toPrint)->{System.out.println(toPrint);};
    /**/
    demo.printSomething(something, printer);
}

Nous pouvons également rendre le code plus concis que ce qui est affiché ici. Lorsque cela se produit, vous n'avez même pas besoin de spécifier le type du paramètre sur le côté gauche de la flèche, et son type sera déduit par le compilateur en fonction des paramètres formels de la méthode d'interface.

Printer printer = (toPrint)->{System.out.println(toPrint);};

Nous pouvons faire mieux. Une autre caractéristique de lambda est que s'il n'y a qu'un seul paramètre, les parenthèses peuvent être complètement éliminées. De même, s'il n'y a qu'une seule instruction à droite de la flèche, vous pouvez également supprimer les accolades :

Printer printer = toPrint -> System.out.println(toPrint);

Maintenant, le code a l'air vraiment mignon . Mais nous ne faisons que commencer. Si notre méthode d'interface ne nécessite aucun paramètre, nous pouvons remplacer la vie par une paire de crochets vides :

() -> System.out.println("anything");

Si nous inlineons simplement Et si un lambda entre sans créer au préalable un objet et le transmettre à la méthode saySomething :

public static void main(String[] args) {
    LambdaDemo demo = new LambdaDemo();
    String something="I am Lambda";    /**/
    demo.printSomething(something, toPrint -> System.out.println(toPrint));
}

Maintenant, nous parlons vraiment de programmation fonctionnelle. Notre corps de fonction principal a été réduit de 9 lignes de code au début à 3 lignes de code. Un code aussi compact rend les expressions lambda très attrayantes pour les programmeurs Java.

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!