Java Lambda表达式的使用详解

目录

• 一、前言
• 二、Lambda表达式概述
• 1. 什么是Lambda表达式？
• 三、Lambda表达式的语法规则
• 1. 无参数的Lambda表达式
• 2. 单个参数的Lambda表达式
• 3. 多个参数的Lambda表达式
• 4. 方法体只有一行代码时，可以省略{}和return
• 5. 方法体有多行代码时，需要使用{}和return
• 四、函数式接口与Lambda表达式
• 1. 什么是函数式接口？
• 2. Java内置函数式接口
• 五、Lambda表达式在集合中的应用
• 1. List遍历
• 2. Map遍历
• 3. Stream流操作
• 六、Lambda表达式的注意事项
• 总结

一、前言

Lambda表达式是Java 8引入的新特性之一，它极大地简化了代码，特别是在处理集合和使用函数式接口时。

通过Lambda表达式，我们可以将函数作为参数传递，提高了代码的简洁性和可读性。

本文将介绍Lambda表达式的语法、应用场景以及常见用法。

二、Lambda表达式概述

1. 什么是Lambda表达式？

Lambda表达式是一种匿名函数，用于简化对接口的实现。

在没有Lambda之前，我们通常通过匿名内部类的方式来实现接口，而使用Lambda可以用更简洁的方式表示。

Lambda表达式的语法：

(参数列表) -> { 方法体 }

语法解析：

• ()：参数列表，可以为空或包含多个参数。
• ->：Lambda操作符，表示将参数传递给方法体。
• {}：方法体，包含具体实现逻辑。若方法体只有一行语句，可以省略大括号和return编程客栈关键字。

Lambda表达式与匿名内部类的对比：

使用匿名内部类

List<String> list = Arrays.asList("Java", "python", "C++");
Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
});
System.out.println(list);

使用Lambda表达式

List<String> list = Arrays.asList("Java", "Python", "C++");
list.sort((s1, s2) -> s1.compareTo(s2));
System.out.println(list);

使用Lambda表达式后，代码简洁了很多。

三、Lambda表达式的语法规则

1. 无参数的Lambda表达式

如果方法没有参数，可以使用空括号：

Runnable runnable = () -> System.out.println("无参数的Lambda表达式");
new Thread(runnable).start();

2. 单个参数的Lambda表达式

如果只有一个参数，可以省略括号：

Consumer<String> consumer = s -> System.out.println(s);
consumer.accept("单个参数的Lambda表达式");

3. 多个参数的Lambda表达式

有多个参数时，需要使用括号：

BiFunction<Integer, Integer, Integer> sum = (a, b) -> a + b;
System.out.println(sum.apply(5, 10));

4. 方法体只有一行代码时，可以省略{}和return

Function<Integer, Integer> square = x -> x * x;
System.out.println(square.apply(4));

5. 方法体有多行代码时，需要使用{}和return

BiFunction<Integer, Integer, Integer>android multiply = (a, b) -> {
    int result = a * b;
    System.out.println("结果：" + result);
    return result;
};
multiply.apply(3, 4);

四、函数式接口与Lambda表达式

1. 什么是编程函数式接口？

函数式接口是只包含一个抽象方法的接口，可以使用@FunctionalInterface注解进行标记。Lambda表达式可以简化对函数式接口的实现。

自定义函数式接口示例

@FunctionalInterface
public interface MyFunctionalInterface {
    void show();
}

使用Lambda表达式实现：

MyFunctionalInterface myInterface = () -> System.out.println("Lambda实现函数式接口");
myInterface.show();

2. Java内置函数式接口

Java提供了许多内置的函数式接口，常用的有：

• Consumer<T>：消费型接口，有入参无返回值。
• Supplier<T>：供给型接口，无入参有返回值。
• Function<T, R>：函数型接口，有入参有返回值。
• Predicate<T>：断言型接口，返回布尔值。

示例：

import java.util.function.*;

public class LambdaDemo {
    public static void main(String[] args) {
        // Consumer示例
        Consumer<String> consumer = s -> System.out.println("消费：" + s);
        consumer.accept("Java");

        // Supplier示例
        Supplier<String> supplier = () -> "提供数据";
        System.out.println(supplier.get());

        // Function示例
        Function<Integer, String> function = i -> "数字：" + i;
        System.out.println(function.apply(10));

        // Predicate示例
        PredpqdARiFXMzicate<Integer> predicate = n -> n > 5;
        System.out.println(predicate.test(10));
    }
}

五、Lambda表达式在集合中的应用

1. List遍历

使用Lambda表达式简化遍历：

List<String> list = Arrays.asList("Java", "Python", "C++");

// 普通遍历
for (String item : list) {
    System.out.println(item);
}

// 使用Lambda表达式
list.forEach(s -> System.out.println(s));

2. Map遍历

Map<String, Integer> map = new HashMap<>();
map.put("Java", 1);
map.put("Python", 2);
map.put("C++", 3);

// Lambda遍历Map
map.forEach((k, v) -> System.out.println(k + " -> " + v));

3. Stream流操作

Lambda表达式与Stream流结合，可以实现简洁的数据处理：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);

// 筛选偶数并计算平方
List<Integer> squares = numbers.stream()
        .filter(n -> n % 2 == 0)
        .map(n -> n * n)
        .collect(Collectors.toList());

System.out.println(squares);

六、Lambda表达式的注意事项

变量引用：Lambda表达式中引用外部变量时，该变量必须是final或等效于final的（即不可被修改）。

int num = 10;
Runnable r = () -> System.out.println(num);
r.run();

不可以在Lambda表达式内修改num的值。

异常处理：Lambda表达式中可以抛出异常，但需要在接口方法中声明异常。

@FunctionalInterface
interface ThrowingConsumer<T> {
    void accept(T tphp) throws Exception;
}

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程客栈(www.devze.com)。