lambda表达式是什么？

一、Java 的 lambda 表达式

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

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

(parameter_list) -> { body }
1

其中：

• 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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        // 使用Lambda表达式实现List的forEach方法
        names.forEach(name -> System.out.println(name));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

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

import java.util.HashMap;
import java.util.Map;

public class MapForEachExample {
    public static void main(String[] args) {
        Map<Integer, String> 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));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

示例创建了一个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<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 30));
        people.add(new Person("Charlie", 20));

        // 使用Lambda表达式实现Comparator接口来定义排序规则
        Comparator<Person> ageComparator = (person1, person2) -> person1.getAge() - person2.getAge();

        // 对列表进行排序 按照年龄升序排序
        Collections.sort(people, ageComparator);

        // 打印排序后的结果
        for (Person person : people) {
            System.out.println(person.getName() + " - " + person.getAge());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

---

二、python 中的 lambda

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

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

Lambda表达式的一般形式为：

lambda arguments: expression
1

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

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

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

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