Présentation des expressions Lambda, le sucre syntaxique de Java 8

Recommandations d'apprentissage gratuites : Tutoriel de base Java

Introduction aux expressions Lambda

L'expression Lambda est une nouvelle fonctionnalité de Java8 et l'une des nouvelles fonctionnalités les plus intéressantes à apprendre de Java8. (Une autre nouvelle fonctionnalité est la programmation en streaming.) Une expression Lambda est essentiellement un

. Vous pouvez utiliser cette méthode anonyme,

.

• 匿名方法 Fonction : Les expressions lambda sont généralement utilisées pour 实现接口中的方法. Il existe de nombreuses façons d'implémenter des interfaces, telles que : ① Concevoir la classe d'implémentation de l'interface, ② Utiliser des classes internes anonymes. Mais ③ utiliser l'expression lambda est plus simple que ces deux méthodes.

• Exigences : expression lambda, 简化接口实现 : Autrement dit, dans une interface, il n'y a qu'une seule méthode abstraite que la classe d'implémentation doit implémenter.

• 只能实现函数式接口

  est utilisé avant une interface pour déterminer si l'interface est une interface fonctionnelle. S'il ne s'agit pas d'une interface fonctionnelle, une erreur sera signalée. La fonctionnalité est similaire à @Override.

2. Syntaxe de l'expression lambda @FunctionalInterface注解

Une expression lambda est essentiellement une méthode anonyme, donc lors de l'écriture d'une expression lambda, vous n'en avez pas besoin. Peu importe le nom de la méthode et vous n'avez pas besoin de vous soucier du type de valeur de retour. Il n'y a que deux parties dont il faut se soucier : , .

参数列表() Partie paramètre : La liste des paramètres de la méthode doit être cohérente avec la partie paramètre de la méthode dans l'interface implémentée, y compris le nombre et le type de paramètres. 方法体

{}Partie du corps de la méthode : la partie implémentation de la méthode. Si la méthode définie dans l'interface a une valeur de retour, faites attention à la valeur de retour lors de son implémentation.

-> : Sépare la partie paramètre et la partie corps de la méthode.

Lambda表达式基础语法:(参数) ->{
	方法体}

Ce qui suit définit 6 types de

avec différents paramètres et valeurs de retour, et utilise des expressions lambda pour implémenter les méthodes dans l'interface :

函数式接口

Ce qui suit est l'implémentation de l'expression lambda pour les six interfaces fonctionnelles ci-dessus.

/**
 * @Description:
 * @author Guoqianliang
 * @date 19:50 - 2021/2/15
 */public class BasicSyntax {
    public static void main(String[] args) {
        // 1.实现无参数,无返回值的函数式接口
        NoneReturnNoneParameter lambda1 = () -> {
            System.out.println("这是无参,无返回值的方法");
        };
        lambda1.test();

        // 2.实现一个参数,无返回值的函数式接口
        NoneReturnSingleParameter lambda2 = (int a) -> {
            System.out.println("这是一个参数,无返回值的方法,参数a:" + a);
        };
        lambda2.test(10);

        // 3.实现多个参数,无返回值的函数式接口
        NoneReturnMutipleParameter lambda3 = (int a, int b) -> {
            System.out.println("这是多个参数,无返回值的方法,参数a=" + a + ",b=" + b);
        };
        lambda3.test(10, 20);

        // 4.实现无参数,有返回值有返回值的函数式接口
        SingleReturnNoneParameter lambda4 = () -> {
            System.out.println("这是无参数,有返回值的方法,返回值是:");
            return 10;
        };
        System.out.println(lambda4.test());

        // 5.实现一个参数,有返回值的函数式接口
        SingleReturnSingleParameter lambda5 = (int a) -> {
            System.out.println("这是一个参数,有返回值的方法,返回值是:");
            return a;
        };
        System.out.println(lambda5.test(10));

        // 6.实现多个参数,有返回值的函数式接口
        SingleReturnMutipleParameter lambda6 = (int a, int b) -> {
            System.out.println("这是多个参数,有返回值的方法,返回值是:");
            return a + b;
        };
        System.out.println(lambda6.test(1, 2));
    }}

Simplification avancée de la syntaxe :

Le type de paramètre de la liste de paramètres peut être omis.

S'il y a un et un seul paramètre dans la liste des paramètres, les parenthèses peuvent être omises.

S'il n'y a qu'une seule instruction dans le corps de la méthode, les accolades peuvent être omises. (Remarque : si cette instruction est une instruction return, le mot-clé return doit également être omis après avoir omis les accolades)
• Référence de la fonction

Les expressions Lambda visent à simplifier l'interface. Dans les expressions lambda, une logique plus complexe ne devrait pas apparaître. Si la logique à traiter est relativement complexe, une méthode distincte sera généralement écrite. Référencez simplement cette méthode directement dans l’expression lambda. Autrement dit,

1. Syntaxe de référence de méthode statique 引用一个已经存在的方法，使其代替lambda表达式完成接口的实现。

 :

dans la référence Après la méthode, n'ajoutez pas de parenthèses. Les paramètres (numéro, type) et valeur de retour de la méthode référencée par

类::静态方法 doivent être cohérents avec ceux définis dans l'interface.

• /**
   * @Description: 方法引用
   * @author Guoqianliang
   * @date 0:26 - 2021/2/16
   */public class Lambda1 {
  
      private static interface Calculate {
          int calculate(int a, int b);
      }
  
      private static int calculate(int x, int y) {
          if (x > y) {
              return x - y;
          } else if (x 

• 2. Référence de méthode non statique

Syntaxe :

dans référence Après la méthode, n'ajoutez pas de parenthèses. Les paramètres (numéro, type) et valeur de retour de la méthode référencée par

对象::非静态方法 doivent être cohérents avec ceux définis dans l'interface.

• /**
   * @Description: 方法引用
   * @author Guoqianliang
   * @date 0:26 - 2021/2/16
   */public class Lambda1 {
  
      private static interface Calculate {
          int calculate(int a, int b);
      }
  
      // 非静态方法
      private int calculate2(int a, int b) {
          if (a != b) {
              return a - b;
          }
          return a + b;
      }
  
      public static void main(String[] args) {
          // 非静态方法引用
          Calculate calculate2 = new Lambda1()::calculate2;
          System.out.println(calculate.calculate(10, 20));
      }}

• 3. Référence de la méthode du constructeur

Syntaxe :

peut être transmise via l'interface Les paramètres de la méthode dans la méthode font référence à différents constructeurs.

类名::newSi une méthode définie dans une interface fonctionnelle sert simplement à obtenir un objet d'une classe. À ce stade, vous pouvez utiliser la référence à la méthode constructeur pour simplifier l’implémentation de cette méthode.

• /**
   * @Description: 构造方法引用
   * @author Guoqianliang
   * @date 11:20 - 2021/2/16
   */public class Lambda2 {
  
      @FunctionalInterface
      private interface GetPersonWithNoneParameter {
          Person get();
      }
  
      @FunctionalInterface
      private interface GetPersonWithSingleParameter {
          Person get(String name);
      }
  
      @FunctionalInterface
      private interface GetPersonWithMutipleParameter {
          Person get(String name, int age);
      }
  
      private static class Person {
          String name;
          int age;
  
          public Person() {
              System.out.println("Person类的无参构造方法执行了");
          }
  
          public Person(String name) {
              this.name = name;
              System.out.println("Person类的有参构造方法执行了");
          }
  
          public Person(String name, int age) {
              this.name = name;
              this.age = age;
              System.out.println("Person类的两个参数的构造方法执行了");
          }
      }
  
      public static void main(String[] args) {
          // 1.使用lambda表达式,实现GetPersonWithNoneParameter接口
          GetPersonWithNoneParameter getPerson = Person::new;
          // 2.使用lambda表达式,实现GetPersonWithSingleParameter接口
          GetPersonWithSingleParameter getPerson2 = Person::new;
          // 3.使用lambda表达式,实现GetPersonWithMutipleParameter接口
          GetPersonWithMutipleParameter getPerson3 = Person::new;
  
          System.out.println(getPerson.get());
          System.out.println(getPerson2.get("树先生"));
          System.out.println(getPerson3.get("你好", 23));
      }}

• 4. Références spéciales aux méthodes d'objet

Lors de l'utilisation d'expressions lambda pour implémenter certaines interfaces, si dans l'expression lambda contient un objet. Dans le corps de la méthode, utiliser directement cet objet pour appeler l'une de ses méthodes peut compléter la logique globale.

/**
 * @Description: 对象方法的特殊应用
 * @author Guoqianliang
 * @date 11:54 - 2021/2/16
 */public class Lambda3 {

    @FunctionalInterface
    private interface MyInterface {
        // String get(Person person);
        void set(Person person, String name);
    }

    private static class Person {
        private String name;

        public void setName(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("小明");//        逻辑实现只是为了获取到对象的名字//        MyInterface lambda2 = Person::getName;//        System.out.println(lambda2.get(p1));
        
        // 逻辑实现只是为了给对象的某些属性进行赋值
        MyInterface lambda1 = (x, n) -> x.setName(n);
        MyInterface lambda2 = Person::setName;
        lambda2.set(p1, "李华");
        System.out.println(p1.getName());
    }}

4. Problèmes auxquels il faut prêter attention avec les expressions Lambda

Si est utilisé, il sera déclaré comme une constante par défaut, ce qui ne peut pas entraîner de changements de valeur.

/**
 * @Description:
 * @author Guoqianliang
 * @date 13:05 - 2021/2/16
 */public class Lambda4 {
    public static void main(String[] args) {
        // 1.定义一个局部变量
        int x = 10;
        // 2.使用lambda表达式实现接口
        LambdaTest lambda = () -> {
            System.out.println("x=" + x);
        };
        // 3. 无法修改常量x
        // x=20;
    }}@FunctionalInterfaceinterface LambdaTest {
    void test();}

局部变量Recommandations d'apprentissage associées :

bases de 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!