lambda表达式是什么？

文章目录

• 一、Java 的 lambda 表达式
• • 1.1 lamdba表达式实现函数式接口
  • 1.2 实现集合类的forEach方法
  • 1.3 lamdba实现Comparator接口排序
  • 二、python 中的 lambda

    一、Java 的 lambda 表达式

    Java 8 中引入 lambda 表达式，它是一种匿名函数，可作为参数传递给方法或存储在变量中。Lambda 表达式比较简洁、易读。

    
    （图片来源网络，侵删）

    Lambda 表达式的基本语法如下：

    (parameter_list) -> { body }
    

    其中：

    • parameter_list：是参数列表，可以为空或包含一个或多个参数。
    • ->：是 Lambda 操作符，用来分隔参数列表 Lambda 表达式主体。
    • { body }：是表达式主体，即具体逻辑。

      Lambda 表达式可以代替传统的匿名内部类，使用 Lambda 表达式可以更简洁地实现函数式编程的特性。Lambda 表达式可以用在函数式接口（Functional Interface）上，函数式接口是只包含一个抽象方法的接口。

      Lambda 表达式的优点包括：

      1. 简洁：减少了冗余的代码，使代码更加简洁易读。
      2. 易用：Lambda 表达式可以直接传递给方法，简化了代码的编写。
      3. 并行处理：可以方便地实现并行处理，提高程序的性能。

      Lambda 表达式的应用场景包括集合操作、事件处理、线程处理等。在 Java 中，常见的使用 Lambda 表达式的地方包括集合类的 forEach 方法、Comparator 接口的排序方法、线程的创建等。

      1.1 lamdba表达式实现函数式接口

      在Java中使用Lambda表达式来实现一个函数式接口：

      函数式接口是只包含一个抽象方法的接口，Lambda表达式可以用来实现该接口的抽象方法。

      // 定义一个函数式接口
      interface MathOperation {
          int operate(int a, int b);//抽象方法
      }
      public class LambdaExample {
          public static void main(String[] args) {
              // 使用Lambda表达式实现MathOperation接口的抽象方法
              MathOperation addition = (int a, int b) -> a + b;
              MathOperation subtraction = (int a, int b) -> a - b;
              // 调用Lambda表达式实现的方法
              System.out.println("3 + 4 = " + operate(3, 4, addition));
              System.out.println("3 - 4 = " + operate(3, 4, subtraction));
          }
          // 接受MathOperation接口实例作为参数的方法
          public static int operate(int a, int b, MathOperation mathOperation) {
              return mathOperation.operate(a, b);
          }
      }
      

      1.2 实现集合类的forEach方法

      实现List和Map集合类的forEach方法：

      1. 使用Lambda表达式实现List集合类的forEach方法：

      import java.util.ArrayList;
      import java.util.List;
      public class ListForEachExample {
          public static void main(String[] args) {
              List names = new ArrayList();
              names.add("Alice");
              names.add("Bob");
              names.add("Charlie");
              // 使用Lambda表达式实现List的forEach方法
              names.forEach(name -> System.out.println(name));
          }
      }
      

      遍历集合中的元素并输出每个元素的值。

      1. 使用Lambda表达式实现Map集合类的forEach方法：

      import java.util.HashMap;
      import java.util.Map;
      public class MapForEachExample {
          public static void main(String[] args) {
              Map students = new HashMap();
              students.put(1, "Alice");
              students.put(2, "Bob");
              students.put(3, "Charlie");
              // 使用Lambda表达式实现Map的forEach方法
              students.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));
          }
      }
      

      示例创建了一个Map集合类students，使用Lambda表达式实现了forEach方法，遍历Map中的键值对并输出每个键值对的键和值。

      通过使用Lambda表达式，可以简洁地实现集合类的forEach方法，提高代码的可读性和简洁性。Lambda表达式是Java 8引入的一个重要特性，使得函数式编程在Java中更加便捷。

      1.3 lamdba实现Comparator接口排序

      Java使用Lambda表达式来实现Comparator接口，来实现自定义的比较器逻辑。下面是使用Lambda表达式实现Comparator接口来对一个对象列表进行排序：

      import java.util.ArrayList;
      import java.util.Collections;
      import java.util.Comparator;
      import java.util.List;
      class Person {
          String name;
          int age;
          public Person(String name, int age) {
              this.name = name;
              this.age = age;
          }
          public String getName() {
              return name;
          }
          public int getAge() {
              return age;
          }
      }
      public class ComparatorLambdaExample {
          public static void main(String[] args) {
              List people = new ArrayList();
              people.add(new Person("Alice", 25));
              people.add(new Person("Bob", 30));
              people.add(new Person("Charlie", 20));
              // 使用Lambda表达式实现Comparator接口来定义排序规则
              Comparator ageComparator = (person1, person2) -> person1.getAge() - person2.getAge();
              // 对列表进行排序 按照年龄升序排序
              Collections.sort(people, ageComparator);
              // 打印排序后的结果
              for (Person person : people) {
                  System.out.println(person.getName() + " - " + person.getAge());
              }
          }
      }
      

      ---

      二、python 中的 lambda

      在python中，Lambda表达式通常由以下几部分组成：

      1. 关键字：通常是"lambda"关键字，用于表示定义一个lambda表达式。
      2. 参数列表：lambda表达式的参数列表，类似于函数的参数列表，用于接收传入的参数。
      3. 冒号：用于分隔参数列表和lambda表达式的函数体。
      4. 表达式：lambda表达式的函数体，用于定义函数的逻辑。

      Lambda表达式的一般形式为：

      lambda arguments: expression
      

      以下是一个简单的lambda表达式示例：

      add = lambda x, y: x + y
      print(add(3, 4))  # 输出结果为7
      

      Lambda表达式通常用于简单的函数逻辑 或 作为参数传递给高阶函数。

      通常用于函数式编程语言或支持函数式编程特性的编程语言中。Lambda表达式可以用来创建小型的、临时的、一次性的函数，而不需要给函数命名或定义函数体。