Comment comprendre les expressions lambda en Java

Cet article vous apporte des connaissances pertinentes sur java, qui introduit principalement les problèmes liés aux expressions lambda. Les expressions lambda sont une nouvelle forme de syntaxe après le démarrage du JDK8, qui peut simplifier le code des classes internes anonymes. méthode d’écriture. J’espère que cela sera utile à tout le monde.

Apprentissage recommandé : "Tutoriel vidéo Java"

Présentation de Lambda

L'expression Lambda est une nouvelle forme de syntaxe après le démarrage de JDK8

Fonction :Simplifier le code des classes internes anonymes Méthode d'écriture

Format :

(匿名内部类被重写方法的形参列表)->{
    被重写方法的方法体代码
}
注：->是语法形式，无实际意义

Nous définissons d'abord une classe abstraite, réécrivons sa méthode via une classe interne anonyme, puis la simplifions et comparons les changements entre les deux :

Utiliser l'expression Lambda Avant :

public static void main (String[] args){
    People p = new People(){
    @Override
    public void run(){
        System.out.println("小学生跑的很慢");
        }
    };
    p.run();    

}
abstract class People{
    public abstract void run();
}

Après avoir utilisé l'expression Lambda :

People p = ()->{
    System.out.println("小学生跑的很慢");
};
//会出现报错

Une erreur apparaîtra. Pourquoi ? La raison en est que la définition précédente de l'expression Lambda n'est pas claire. L'expression Lambda ne peut pas simplifier toutes les classes internes anonymes. Elle ne peut que simplifier la forme d'écriture des classes internes anonymes dans les interfaces fonctionnelles, et il n'y a qu'une seule méthode abstraite dans l'interface . , généralement, nous ajouterons une annotation @Functionalinterface sur l'interface pour marquer que l'interface doit satisfaire l'interface fonctionnelle.

Vraiment simplifié par l'expression Lambda :

@FunctionalInterface//加上这个注解必须是函数式接口，且只有一个抽象方法
interface People{
    void run();
}
//简化之前的匿名内部类
People p = new People(){
    @Override
    public void run(){
        System.out.println("小学生跑的很慢！");
    }
};
//简化之后
People p = () -> {
        System.out.println("小学生跑的很慢！");
};

De plus, vous pouvez également

la remplacer comme paramètre dans la méthode :

//在原来的基础上定义一个pk方法
public static void pk(People p){
    System.out.println("跑步情况如何：")
    p.run();
}
//不使用Lambda的情况下：
pk(p);//需要在定义匿名内部类之后，将p代入；
//使用Lambda的情况：
People p = () -> {
        System.out.println("小学生跑的很慢！");
};
pk(() -> {
        System.out.println("小学生跑的很慢！");
});
//由于等号右边即是People创建的对象p，因此可以可以直接将其代入

Avantages de Lambda :

Lambda est une fonction anonyme Nous pouvons. Comprendre l'expression Lambda comme un morceau de code qui peut être transmis. Il peut écrire du code plus simple et plus flexible. En tant que style de code plus compact, la capacité d'expression du langage Java a été améliorée.

Le rôle pratique de Lambda

Dans le processus d'apprentissage précédent, nous avons acquis les connaissances pertinentes sur les tableaux. Il existe une méthode de tri (qui peut trier le tableau par ordre croissant ou décroissant). n'a qu'une seule abstraction. Méthode :

//精简之前:
Arrays.sort(grade,new Comparator<Integer>(){
    @Override
    public int compare(Integer o1,Integer o2){
        return o2 -o1;
}
});
//精简之后:
Arrays.sort(grade,(Integer o1,Integer o2) -> {
        return o2 -o1;
});

Règles d'omission de l'expression Lambda

Le type de paramètre peut être omis sans écrire

• //参考前面的实战例子
  Arrays.sort(grade,(Integer o1,Integer o2) -> {
          return o2 -o1;
  });
  //省略参数类型之后
  Arrays.sort(grade,( o1, o2){
          return o2 -o1;
  });

S'il n'y a qu'un seul paramètre, le type de paramètre peut être omis, et () peut également l'être. omis

• //简单引用一个单个参数的例子，不需要了解其具体含义
  btn.addActionListener((ActionEvent e) -> {
      System.out.println("我是简单的例子。");
  });
  //简化之后：
  btn.addActionListener( e -> {
      System.out.println("我是简单的例子。");
  });

Si l'expression Lambda Le code du corps de la méthode n'a qu'une seule ligne de code. Vous pouvez omettre les accolades et le point-virgule

• //参照上一条规则的例子
  btn.addActionListener( e -> {
      System.out.println("我是简单的例子。");
  });
  //简化之后：
  btn.addActionListener( e -> System.out.println("我是简单的例子。") );

si le code du corps de la méthode de l'expression Lambda ne comporte qu'une seule ligne de code. Vous pouvez omettre les accolades. À l'heure actuelle, si cette ligne de code est une instruction return, return doit être omis et ";" doit également être omis

• //参照第一条规则的代码
  Arrays.sort(grade,(Integer o1,Integer o2) -> {
          return o2 -o1;
  });
  //简化之后：
  Arrays.sort(grade,( o1, o2)-> o2 -o1);

Apprentissage recommandé : "

Tutoriel vidéo 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!