Java Lambda语法

什么是Lambda表达式？

Lambda表达式是Java 8中引入的一个重要特性，它提供了一种简洁的方式来表示可传递的匿名函数：它没有名称，但有参数列表、函数体、返回类型，可能还有一个可以抛出的异常列表。

简单来说，Lambda表达式让我们能够将函数作为方法参数传递，或者将代码作为数据处理。这是Java向函数式编程迈出的重要一步。

备注

Lambda表达式主要用于实现函数式接口（只包含一个抽象方法的接口）。Java 8之前，我们通常使用匿名内部类来实现这些接口。

Lambda表达式基本语法

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

java

(参数列表) -> {函数体}

其中：

• 参数列表：可以是空参数()，单个参数x，或多个参数(x, y)
• 箭头符号：->分隔参数列表和函数体
• 函数体：包含表达式或语句的代码块

简化语法规则

Lambda表达式有几种简化形式：

1. 当参数只有一个且类型可推断时，可以省略小括号：

   java

   x -> x * x

2. 当函数体只有一条语句时，可以省略大括号和return关键字：

   java

   (x, y) -> x + y

3. 当函数体有多条语句时，必须使用大括号和return关键字：

   java

   (x, y) -> {
       int sum = x + y;
       return sum;
   }

Lambda表达式实例

让我们通过几个例子来理解Lambda表达式的使用：

示例1：简单的Lambda表达式

java

// 使用匿名内部类的传统方式
Runnable runnable1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("使用匿名内部类");
    }
};

// 使用Lambda表达式
Runnable runnable2 = () -> System.out.println("使用Lambda表达式");

// 调用方式相同
runnable1.run(); // 输出: 使用匿名内部类
runnable2.run(); // 输出: 使用Lambda表达式

示例2：带参数的Lambda表达式

java

// 使用匿名内部类
Comparator<Integer> comparator1 = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1.compareTo(o2);
    }
};

// 使用Lambda表达式
Comparator<Integer> comparator2 = (o1, o2) -> o1.compareTo(o2);

// 进一步简化，使用方法引用
Comparator<Integer> comparator3 = Integer::compareTo;

// 测试
System.out.println(comparator1.compare(5, 3)); // 输出: 1
System.out.println(comparator2.compare(5, 3)); // 输出: 1
System.out.println(comparator3.compare(5, 3)); // 输出: 1

示例3：多语句的Lambda表达式

java

// 计算两个数的最大公约数
BiFunction<Integer, Integer, Integer> gcd = (a, b) -> {
    if (a < b) {
        int temp = a;
        a = b;
        b = temp;
    }
    
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    
    return a;
};

System.out.println(gcd.apply(48, 18)); // 输出: 6

Lambda表达式与函数式接口

Lambda表达式可以赋值给函数式接口类型的变量。Java 8提供了一系列内置的函数式接口：

常用函数式接口

1. Consumer<T>: 接收一个参数，不返回结果

   java

   Consumer<String> printer = message -> System.out.println(message);
   printer.accept("Hello Lambda"); // 输出: Hello Lambda

2. Function<T, R>: 接收一个参数，返回一个结果

   java

   Function<Integer, String> converter = number -> "Number: " + number;
   System.out.println(converter.apply(42)); // 输出: Number: 42

3. Predicate<T>: 接收一个参数，返回一个布尔值

   java

   Predicate<Integer> isEven = number -> number % 2 == 0;
   System.out.println(isEven.test(4)); // 输出: true
   System.out.println(isEven.test(7)); // 输出: false

4. Supplier<T>: 不接收参数，返回一个结果

   java

   Supplier<Double> randomValue = () -> Math.random();
   System.out.println(randomValue.get()); // 输出随机数，如: 0.7239...

Lambda表达式的变量作用域

Lambda表达式可以访问其外部作用域中的变量，但这些变量必须是effectively final的（即使不声明为final，也不能在Lambda中修改）。

java

int factor = 5;
Function<Integer, Integer> multiplier = n -> n * factor; // 可以访问外部变量
// factor = 10; // 如果取消注释，会导致编译错误

System.out.println(multiplier.apply(2)); // 输出: 10

警告

Lambda表达式中访问的外部局部变量必须是final或effectively final。这是因为Lambda可能在不同的线程中执行，或者在外部变量已经不存在的时候执行。

Lambda表达式与方法引用

方法引用是Lambda表达式的一种简写形式，当Lambda表达式仅调用一个已存在的方法时，可以使用方法引用。

方法引用有四种类型：

1. 静态方法引用：ClassName::staticMethodName
2. 实例方法引用：instance::instanceMethodName
3. 对特定类型实例方法的引用：ClassName::instanceMethodName
4. 构造函数引用：ClassName::new

方法引用示例

java

// 静态方法引用
Function<String, Integer> parser1 = s -> Integer.parseInt(s);
Function<String, Integer> parser2 = Integer::parseInt;

// 实例方法引用
String text = "Hello";
Supplier<Integer> lengthSupplier1 = () -> text.length();
Supplier<Integer> lengthSupplier2 = text::length;

// 对特定类型实例方法的引用
Function<String, String> toUpper1 = s -> s.toUpperCase();
Function<String, String> toUpper2 = String::toUpperCase;

// 构造函数引用
Supplier<ArrayList<String>> listCreator1 = () -> new ArrayList<>();
Supplier<ArrayList<String>> listCreator2 = ArrayList::new;

实际应用场景

集合操作

Java 8的Stream API与Lambda表达式配合使用，可以简化集合操作：

java

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Dave", "Eve");

// 过滤以'A'开头的名字并转换为大写
List<String> filteredNames = names.stream()
        .filter(name -> name.startsWith("A"))
        .map(String::toUpperCase)
        .collect(Collectors.toList());

System.out.println(filteredNames); // 输出: [ALICE]

// 计算名字的平均长度
double averageLength = names.stream()
        .mapToInt(String::length)
        .average()
        .orElse(0);

System.out.println("Average name length: " + averageLength); // 输出: Average name length: 4.2

事件处理

Lambda表达式在GUI编程中特别有用，可以简化事件监听器的代码：

java

// 传统方式
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Button clicked!");
    }
});

// Lambda方式
button.addActionListener(e -> System.out.println("Button clicked!"));

多线程编程

Lambda表达式简化了多线程代码：

java

// 传统方式
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}).start();

// Lambda方式
new Thread(() -> System.out.println("Thread running")).start();

小心Lambda表达式的陷阱

在使用Lambda表达式时，需要注意以下几点：

1. 避免副作用：Lambda表达式最好是纯函数，不应该修改外部状态
2. 注意变量捕获规则：Lambda只能访问final或effectively final的局部变量
3. 不要过度使用：有时传统的循环可能比Stream API配合Lambda更易读
4. 注意异常处理：Lambda表达式中的异常处理需要特别注意

java

// 不好的做法 - 有副作用
List<Integer> numbers = new ArrayList<>();
List<Integer> evens = new ArrayList<>();
numbers.forEach(n -> {
    if (n % 2 == 0) {
        evens.add(n); // 修改外部状态
    }
});

// 更好的做法
List<Integer> evens = numbers.stream()
        .filter(n -> n % 2 == 0)
        .collect(Collectors.toList());

总结

Lambda表达式是Java 8引入的一项重要特性，它为Java带来了函数式编程的能力。主要优点包括：

• 代码更加简洁清晰
• 消除匿名内部类的冗余代码
• 可以将函数作为参数传递
• 支持并行处理数据

通过Lambda表达式，我们可以编写更加简洁、可读性更高的代码，尤其在集合操作、数据处理和事件处理等方面。

提示

学习Lambda表达式时，建议先从简单用法开始，逐步掌握更复杂的用法。结合Stream API学习会更有成效。

练习

为了巩固对Lambda表达式的理解，尝试完成以下练习：

1. 使用Lambda表达式编写一个字符串排序程序，按照字符串长度排序。
2. 使用Lambda表达式和Stream API筛选出一个整数列表中的所有素数。
3. 编写一个方法，该方法接受一个操作(Operation)函数接口，对两个整数进行计算。然后使用Lambda表达式实现加、减、乘、除操作。

进一步学习资源

• Java 8官方文档中关于Lambda表达式的部分
• 学习Java Stream API，这与Lambda表达式配合使用效果更佳
• 研究Java中的函数式接口（java.util.function包）
• 探索Java 8中的其他新特性，如方法引用、默认方法等

通过掌握Lambda表达式，你将能够编写更现代、更简洁的Java代码，并为学习其他现代编程语言打下基础。