Explication détaillée des expressions Lambda dans les exemples Java

Cet article vous apporte des connaissances pertinentes sur java, qui introduit principalement les problèmes liés aux expressions Lambda. Les expressions Lambda introduisent un opérateur **"->"** dans le langage Java, cet opérateur est appelé opérateur Lambda ou opérateur flèche. , jetons-y un coup d'œil ensemble, j'espère que cela sera utile à tout le monde

Apprentissage recommandé : "Tutoriel vidéo Java"

1 Première introduction à Lambda

Nous savons qu'en Java, les interfaces ne peuvent pas être instanciées, mais les objets d'interface peuvent pointer vers leurs objets de classe d'implémentation. Que se passe-t-il si l'interface n'a même pas d'objet d'implémentation ? Vous pouvez également utiliser des classes anonymes, comme suit :

public class JavaTest {
    public static void main(String[] args) {
        Fly fly = new Fly() {
            @Override
            public void fly(String name) {
                System.out.println(name + "飞行");
            }
        };
        fly.fly("张三");
    }}interface Fly{
    abstract void fly(String name);}

Cependant, en utilisant la méthode interne anonyme, la quantité de code n'est en fait pas très concise. Afin de rendre le code plus concis, Java a introduit la méthode d'expression Lambda, via. Pour réaliser une telle fonction avec une syntaxe plus simple, le code simplifié utilisant les expressions Lambda est le suivant :

public class JavaTest {
    public static void main(String[] args) {
        Fly fly = name -> System.out.println(name + "飞行");
        fly.fly("张三");
    }}interface Fly{
    abstract void fly(String name);}

Le même effet est obtenu grâce aux expressions Lambda, mais la quantité de code est très simplifiée. C'est le charme des expressions Lambda.

2. Interface fonctionnelle

Avant d'apprendre la syntaxe des expressions Lambda, vous devez d'abord savoir ce qu'est une interface fonctionnelle Une interface qui n'a qu'une une méthode à implémenter est appelée une interface fonctionnelle.

//接口中只有一个待实现的方法 fly,所以这是函数式接口interface Fly{
     void fly(String name);}//接口中有两个待实现的方法 这是不是函数式接口interface Run{
    void fastRun();
    void slowRun();}//接口中有两个方法,但其中一个是已经定义好的default方法，真正需要子类去实现的方法只有一个 这是函数式接口interface Jump{
    void jump();
    default void highJump(){
        System.out.println("跳的更高");
    }}

Vous pouvez ajouter l'annotation **@FunctionalInterface à l'interface pour affirmer que l'interface est une interface fonctionnelle. Si l'interface n'est pas une interface fonctionnelle, la compilation provoquera une erreur.

Pourquoi a-t-on besoin de savoir ce qu'est une interface fonctionnelle ? Étant donné que les expressions Lambda simplifient l'implémentation de classe anonyme d'une interface, elles ne fonctionnent que sur les interfaces fonctionnelles**. C'est facile à comprendre. Si une interface a plusieurs méthodes à implémenter, l'expression Lambda ne peut pas indiquer quelle méthode dans l'interface elle est actuellement implémentée.

3. Syntaxe de l'expression Lambda

L'expression Lambda introduit un opérateur **"->"** dans le langage Java, appelé opérateur Lambda ou opérateur de flèche. Il divise Lambda en deux parties :

Le côté gauche : spécifie tous les paramètres requis par l'expression Lambda

Le côté droit : formule le corps Lambda, c'est-à-dire la fonction à remplir par l'expression Lambda.
Comme ceci :

(parameters) -> expression
或
(parameters) ->{ statements; }

En plus de -> et du corps Lambda, d'autres paramètres des expressions Lambda, tels que les paramètres, les parenthèses et les crochets, peuvent être omis en fonction du type de paramètre et du numéro de ligne du code du corps de la méthode.

Prenons l'exemple de l'implémentation de l'interface fonctionnelle suivante :

interface MathOperation {
        int operation(int a, int b);
    }

    interface GreetingService {
        void sayMessage(String message);
    }

    private int operate(int a, int b, MathOperation mathOperation){
        return mathOperation.operation(a, b);
    }
    
    interface NoParam{
        int returnOne();
    }

Voici les caractéristiques importantes des expressions lambda :

• Déclaration de type facultative : les expressions lambda n'ont pas besoin de déclarer les types de paramètres des méthodes d'implémentation, et le compilateur peut les identifier uniformément par la valeur du paramètre.

        // 类型声明
        MathOperation addition = (int a, int b) -> a + b;
        // 不用类型声明
        MathOperation subtraction = (a, b) -> a - b;

• Parenthèses de paramètres facultatives : Un paramètre n'a pas besoin d'être défini avec des parenthèses, mais aucun paramètre ou plusieurs paramètres ne doivent être définis avec des parenthèses.

      // 不用括号
        GreetingService greetService1 = message ->
                System.out.println("Hello " + message);

        // 用括号
        GreetingService greetService2 = (message) ->
                System.out.println("Hello " + message);

• Orthèses facultatives : Si le corps contient une déclaration, il n'est pas nécessaire d'utiliser des accolades.

     // 多条语句不可以省略大括号
        MathOperation multiplication = (int a, int b) -> {
            int num = a+1;
            num = a + b;
            return a * b + num;
        };

        // 单条语句可以省略大括号
        MathOperation pision = (int a, int b) -> a / b;

• Mot-clé de retour facultatif : Si le corps n'a qu'une seule valeur de retour d'expression, le compilateur renverra automatiquement la valeur. Les accolades doivent spécifier que l'expression renvoie une valeur.

  // 多条语句的Lambda表达式如果有返回值，需要使用return
        MathOperation multiplication = (int a, int b) -> {
            int num = a+1;
            num = a + b;
            return a * b + num;
        };

        // 单条语句可以省略return
        MathOperation pision = (int a, int b) -> a / b;

4. Portée d'utilisation des expressions Lambda

Les expressions Lambda ne sont pas seulement utilisées pour simplifier la création d'une classe anonyme, elles ont plus d'utilités.

1. Attribuer des valeurs aux variables

Dans ce qui précède, l'utilisation des expressions Lambda consiste à attribuer des valeurs aux variables. Cela peut simplifier le segment de code de l'affectation de classe interne anonyme et améliorer l'efficacité de la lecture.

MathOperation subtraction = (a, b) -> a - b;

2. Comme résultat de retour

interface MathOperation {
        int operation(int a, int b);
    }

    MathOperation getOperation(int a, int b){
        return (a1, b1) -> a+b;
    }

3. En tant qu'élément de tableau

MathOperation math[] = {
                (a,b) -> a+b,
                (a,b) -> a-b,
                (a,b) -> a*b        };

4. En tant que paramètre d'une méthode ordinaire ou d'une méthode constructeur

public static void main(String args[]){

        Java8Tester java8Tester = new Java8Tester();
        java8Tester.operate(1,2,((a, b) -> a*b));

    }

    private int operate(int a, int b, MathOperation mathOperation){
        return mathOperation.operation(a, b);
    }

    interface MathOperation {
        int operation(int a, int b);
    }

5. Portée de l'expression Lambda

Dans le corps de l'expression Lambda, vous pouvez Les variables en dehors de l'expression sont accessibles, mais les autres variables ne peuvent pas être modifiées.

6. Méthode d'écriture de référence de l'expression Lambda

Lors de l'apprentissage de Lambda, vous pouvez également trouver une façon étrange d'écrire, comme le code suivant :

// 方法引用写法GreetingService greetingService = System.out::println;
        greetingService.sayMessage("hello world");

Un symbole que vous n'avez jamais vu auparavant apparaît ici : : , ceci la façon d’écrire est appelée une référence de méthode.

Évidemment, utiliser des références de méthode est plus simple que les expressions Lambda ordinaires.

Si

l'implémentation d'une interface fonctionnelle s'avère être réalisée en appelant une méthode, alors nous pouvons utiliser des références de méthode.

public class Java8Tester {


    public static void main(String args[]){

        // 静态方法引用--通过类名调用
        GreetingService greetingService = Test::MyNameStatic;
        greetingService.sayMessage("hello");
        Test t = new Test();
        //实例方法引用--通过实例调用
        GreetingService greetingService2 = t::myName;
        // 构造方法方法引用--无参数
        Supplier<test> supplier = Test::new;
        System.out.println(supplier.get());
    }



    interface GreetingService {
        void sayMessage(String message);
    }}class Test {
    // 静态方法
    public static void MyNameStatic(String name) {
        System.out.println(name);
    }

    // 实例方法
    public void myName(String name) {
        System.out.println(name);
    }

    // 无参构造方法
    public Test() {
    }}</test>

7、Lambda表达式的优缺点

优点：

• 更少的代码行-lambda表达式的最大好处之一就是减少了代码量。我们知道，lambda表达式只能与功能接口一起使用。例如，Runnable 是一个接口，因此我们可以轻松地应用lambda表达式。

• 通过将行为作为方法中的参数传递来支持顺序和并行执行-通过在Java 8中使用Stream API，将函数传递给collection方法。现在，集合的职责是以顺序或并行的方式处理元素。

• 更高的效率-过使用Stream API和lambda表达式，可以在批量操作集合的情况下获得更高的效率(并行执行)。 此外，lambda表达式有助于实现集合的内部迭代，而不是外部迭代。

缺点

• 运行效率-若不用并行计算，很多时候计算速度没有比传统的 for 循环快。（并行计算有时需要预热才显示出效率优势）
• 很难调试-Lambda表达式很难打断点，对调式不友好。
• 不容易看懂-若其他程序员没有学过 lambda 表达式，代码不容易让其他语言的程序员看懂（我学Lambda表达式的原因是看不懂同事写的Lambda表达式代码）

推荐学习：《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!