lambda表达式本质上是匿名函数，用于将函数作为参数传递或简化匿名内部类的写法。1.它依赖函数式接口（只有一个抽象方法的接口），通过@functionalinterface注解可显式声明；2.主要应用场景包括集合排序、数据处理和事件监听，分别通过comparator、predicate等接口结合stream api实现；3.其语法糖包括类型推断、单语句块省略花括号和return、以及方法引用；4.与匿名内部类的区别在于this指向不同、变量捕获更灵活、编译方式不同；5.适合用于逻辑简单、代码简洁性优先的场景，不适合主体复杂、需大量外部变量或抛出checked exception的情况。

lambda表达式本质上是匿名函数，它允许你将函数作为方法的参数传递，或者将代码像数据一样传递。简单来说，它是一种更简洁地编写匿名内部类的方式。

lambda表达式的使用主要围绕函数式接口。函数式接口是只有一个抽象方法的接口。Java 8 引入了 @FunctionalInterface 注解，虽然不是必须的，但推荐使用它来显式声明一个接口是函数式接口。

lambda表达式的3个经典案例

案例一：使用 lambda 表达式进行集合排序

立即学习“Java免费学习笔记（深入）”；

假设我们有一个 Person 类：

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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

现在，我们有一个 Person 对象的列表，我们想根据年龄对其进行排序。使用 lambda 表达式可以这样写：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class LambdaExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));
        people.add(new Person("Charlie", 35));

        // 使用 lambda 表达式根据年龄排序
        Collections.sort(people, (p1, p2) -> p1.getAge() - p2.getAge());

        System.out.println(people); // 输出: [Person{name='Bob', age=25}, Person{name='Alice', age=30}, Person{name='Charlie', age=35}]
    }
}

在这个例子中，(p1, p2) -> p1.getAge() - p2.getAge() 就是一个 lambda 表达式，它实现了 Comparator 接口的 compare 方法。 不再需要写冗长的匿名内部类了。

案例二：使用 lambda 表达式处理集合数据

假设我们想筛选出 Person 列表中所有年龄大于 30 的人。使用 lambda 表达式和 Stream API 可以这样写：

JavaStoryDevelop

你接手一个需求时，是不是经常这样："改一个小字段 → 结果把不相关的代码也改了"、"需求说得很模糊 → 做着做着发现跑偏了"、"数据库加个字段 → 上线才发现漏了数据兼容"、"做了个新功能 → 一个月后自己都忘了当时怎么设计的"、"写到一半被中断 → 再回来不知道从哪继续"；这个 Skill 就是专门解决这些问题的。 它会自动探测你的项目环境（JDK、Spring Boot、ORM、数据库、前端框架），记在

下载

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));
        people.add(new Person("Charlie", 35));
        people.add(new Person("David", 40));

        // 使用 lambda 表达式筛选年龄大于 30 的人
        List<Person> olderPeople = people.stream()
                .filter(p -> p.getAge() > 30)
                .collect(Collectors.toList());

        System.out.println(olderPeople); // 输出: [Person{name='Charlie', age=35}, Person{name='David', age=40}]
    }
}

这里，p -> p.getAge() > 30 是一个 lambda 表达式，它实现了 Predicate 接口的 test 方法，用于筛选满足条件的元素。Stream API 提供了很多方便的方法，结合 lambda 表达式可以高效地处理集合数据。

案例三：使用 lambda 表达式实现事件监听器

在 GUI 编程中，我们经常需要处理事件。使用 lambda 表达式可以简化事件监听器的代码。例如，在 Swing 中：

import javax.swing.*;
import java.awt.*;

public class LambdaExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Lambda Example");
        JButton button = new JButton("Click Me");

        // 使用 lambda 表达式添加 ActionListener
        button.addActionListener(e -> {
            System.out.println("Button clicked!");
            JOptionPane.showMessageDialog(frame, "Button clicked!");
        });

        frame.getContentPane().add(button);
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

在这个例子中，e -> { ... } 是一个 lambda 表达式，它实现了 ActionListener 接口的 actionPerformed 方法。当按钮被点击时，lambda 表达式中的代码会被执行。

什么是函数式接口？为什么要用它？

函数式接口是只有一个抽象方法的接口。 为什么要用它？因为lambda表达式需要一个“目标类型”。这个目标类型就是函数式接口。Lambda表达式本质上是实现了这个函数式接口的匿名类的实例。 Java 8 规定，lambda 表达式只能实现函数式接口。

lambda表达式的语法糖有哪些？

lambda表达式可以写得很简洁，这得益于一些语法糖：

• 类型推断： 编译器可以根据上下文推断 lambda 表达式的参数类型，因此可以省略参数类型声明。比如 (p1, p2) -> ... 中的 p1 和 p2 的类型可以省略。
• 单语句块： 如果 lambda 表达式的主体只有一个语句，可以省略花括号 {} 和 return 关键字。 比如 p -> p.getAge() > 30。
• 方法引用： 如果 lambda 表达式的主体只是调用一个现有的方法，可以使用方法引用来简化代码。 比如 people.forEach(System.out::println)。

lambda表达式和匿名内部类的区别是什么？

虽然 lambda 表达式在很多情况下可以替代匿名内部类，但它们之间还是有一些区别：

• this 关键字： 在匿名内部类中，this 关键字指向匿名内部类的实例；而在 lambda 表达式中，this 关键字指向 lambda 表达式所在的类的实例。
• 变量捕获： 匿名内部类可以捕获外部的变量，但要求这些变量是 final 的，或者实际上是 final 的（effectively final）。 Lambda 表达式也有类似的限制，但更加灵活。
• 编译方式： 匿名内部类会被编译成一个独立的 .class 文件；而 lambda 表达式在运行时会被动态地生成一个类，并使用 invokedynamic 指令来调用。

什么时候应该使用lambda表达式？什么时候不应该使用？

使用 lambda 表达式可以使代码更简洁、更易读，但在某些情况下，使用 lambda 表达式可能会降低代码的可读性。

• 应该使用： 当需要将函数作为参数传递给方法，或者需要实现一个简单的函数式接口时，可以使用 lambda 表达式。
• 不应该使用： 当 lambda 表达式的主体过于复杂，或者需要捕获大量的外部变量时，应该考虑使用传统的匿名内部类或者普通的方法。此外，如果lambda表达式会抛出checked exception，且调用处没有处理，也不太适合使用lambda表达式。

总之，lambda 表达式是一种强大的工具，可以简化代码，提高开发效率。 但是，也需要根据实际情况选择合适的编程方式，避免滥用 lambda 表达式，导致代码可读性降低。