当前位置：首页 > news >正文

Java Lambda表达式与函数式编程指南

news 2025/11/11 11:22:44

🎯 适合人群：Java小白到进阶开发者
🧭 学习目标：彻底弄懂函数式编程思想、Lambda 表达式语法、函数式接口、常见用法与坑位
⏱️ 阅读时长：约25-35分钟

🧠 一、函数式编程思想概述

在数学中，函数是一套“输入 → 输出”的计算方案（关注“对数据做什么”）。
在面向对象（OOP）中，我们通常“先有对象，再通过对象做事情”。
函数式思想尽量忽略对象的复杂语法，强调“做什么”，而不是“以什么形式去做”。
Lambda 表达式就是 Java 函数式思想的体现：用更简洁的语法传递“行为”。

记忆点：

OOP 强调“名词”（对象），FP（函数式）强调“动词”（行为）。
Lambda 本质是把“一段可执行的代码”当作数据，像参数一样传递给方法。

⚙️ 二、初体验：用 3 种方式启动一个线程

需求：启动一个线程，在控制台输出一句话：“多线程启动了”。

方案1：单独定义类实现 `Runnable`

public class LambdaDemo1 {public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();Thread t = new Thread(myRunnable);t.start();}
}class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("多线程启动了");}
}

方案2：匿名内部类

public class LambdaDemo2 {public static void main(String[] args) {new Thread(new Runnable() {@Overridepublic void run() {System.out.println("多线程启动了");}}).start();}
}

方案3：Lambda 表达式（语法最简洁）

public class LambdaDemo3 {public static void main(String[] args) {new Thread(() -> {System.out.println("多线程启动了");}).start();}
}

要点：

Runnable 是一个“只有一个抽象方法”的接口（称为“函数式接口”）。
只要是函数式接口，就可以用 Lambda 代替冗长的匿名内部类写法。

✍️ 三、Lambda 表达式的标准格式与语法糖

Lambda 的三要素：形式参数、箭头、代码块。

基本格式：

(形式参数) -> { 代码块 }

形式参数：与目标抽象方法的参数一致；0 个参数可写 ()。
箭头 ->：固定写法，读作“去做”。
代码块：要执行的逻辑，相当于方法体。

语法糖（可省略）：

只有一个参数时，参数类型可省略，参数两侧小括号也可省略：x -> x + 1
代码块只有一条语句时，大括号和 return 可省略：(a, b) -> a + b
参数类型一般由目标类型推断，无需显式声明。

✅ 四、Lambda 使用前提与函数式接口

Lambda 使用前提：

必须有一个接口，且该接口有且仅有一个抽象方法（函数式接口）。

可选注解：

@FunctionalInterface // 编译期校验：只有一个抽象方法，否则报错
public interface NoReturnNoParam {void method();
}

JDK 已内置大量函数式接口（java.util.function 包）：

Runnable（无参无返回）
Supplier<T>（供给型，无参有返回）
Consumer<T>（消费型，有参无返回）
Function<T, R>（函数型，有参有返回，T→R）
Predicate<T>（断言型，返回 boolean）
以及 BiFunction、BiConsumer 等双参版本

🧪 五、从你的笔记到可运行的案例（修正与补全）

你的笔记中涉及的几种接口与写法，这里做了修正、补全与演示。

1）无参无返回

@FunctionalInterface
public interface NoReturnNoParam {void method();
}public class DemoNoReturnNoParam {public static void main(String[] args) {// 无参无返回：完整写法NoReturnNoParam a = () -> {System.out.println("NoReturnNoParam");};a.method();// 极简写法（单语句可省略大括号）NoReturnNoParam b = () -> System.out.println("NoReturnNoParam - 简写");b.method();}
}

2）一个参数无返回

@FunctionalInterface
public interface NoReturnOneParam {void method(int a);
}public class DemoNoReturnOneParam {public static void main(String[] args) {// 指定类型写法NoReturnOneParam p1 = (int a) -> {System.out.println("NoReturnOneParam param: " + a);};p1.method(6);// 类型推断 + 省略括号（只有一个参数时）NoReturnOneParam p2 = a -> System.out.println("简写 param: " + a);p2.method(8);}
}

3）多参数无返回 / 有返回

@FunctionalInterface
public interface NoReturnMultiParam {void method(int a, int b);
}@FunctionalInterface
public interface ReturnMultiParam {int method(int a, int b);
}@FunctionalInterface
public interface ReturnOneParam {int method(int a);
}@FunctionalInterface
public interface ReturnNoParam {int method();
}public class LambdaCases {public static void main(String[] args) {// 无参有返回值ReturnNoParam r0 = () -> {System.out.print("ReturnNoParam -> ");return 1;};System.out.println("return: " + r0.method());// 一个参数有返回值（可省类型与大括号）ReturnOneParam r1 = a -> a + 1;System.out.println("return: " + r1.method(6));// 多个参数有返回值（简写）ReturnMultiParam r2 = (a, b) -> a + b;System.out.println("return: " + r2.method(6, 8));// 多参数无返回（打印）NoReturnMultiParam r3 = (a, b) -> System.out.println("sum = " + (a + b));r3.method(10, 20);}
}

🧩 六、常见场景：用 Lambda 写出更干净的代码

1）启动线程（`Runnable`）

new Thread(() -> System.out.println("多线程启动了")).start();

2）排序（`Comparator`）

import java.util.*;public class SortWithLambda {public static void main(String[] args) {List<String> list = new ArrayList<>(Arrays.asList("java", "lambda", "io", "stream"));// 按字符串长度升序list.sort((s1, s2) -> Integer.compare(s1.length(), s2.length()));// 等价方法引用写法：list.sort(Comparator.comparingInt(String::length));System.out.println(list);}
}

3）方法引用（简化 Lambda）

// (x) -> System.out.println(x)  等价  System.out::println
list.forEach(System.out::println);// (a, b) -> a.compareToIgnoreCase(b)  等价  String::compareToIgnoreCase
list.sort(String::compareToIgnoreCase);

4）函数式接口组合（以 Predicate 为例）

import java.util.function.Predicate;public class PredicateCompose {public static void main(String[] args) {Predicate<String> notNull = s -> s != null;Predicate<String> nonEmpty = s -> !s.isEmpty();// 组合：非空 且 非空串Predicate<String> valid = notNull.and(nonEmpty);System.out.println(valid.test("java")); // trueSystem.out.println(valid.test(""));     // falseSystem.out.println(valid.test(null));   // false}
}

🧷 七、重要细节与常见坑

1）变量捕获与“有效 final”

Lambda 里可以使用外部局部变量，但这些变量必须是有效 final（即没有被后续修改）。
原因：Lambda 可能延迟执行，JVM 将捕获变量的“值副本”，保证一致性。

public class CaptureDemo {public static void main(String[] args) {int base = 10; // 有效 final（后续不再修改）Runnable r = () -> System.out.println(base + 5);r.run();// base = 20; // 取消注释将编译错误：从 Lambda 表达式引用的本地变量必须是最终变量或有效最终变量}
}

2）返回值与语句块

代码块只有一条语句时可省略花括号；有 return 时必须保留花括号与 return。

3）目标类型与类型推断

Lambda 的参数类型多数可由编译器从目标接口方法签名推断出来，无需重复声明。

4）方法引用优先

若 Lambda 只是“调用一个已存在的方法”，优先用方法引用，更简洁可读。

5）与匿名内部类的差异

this 在 Lambda 中指向外围类实例；在匿名内部类中，this 指向匿名内部类实例。
重载解析：当存在多个重载方法且目标类型不明确时，可能需要显式类型或强转帮助编译器推断。

🚀 八、与 Stream 的配合（一眼看懂）

Lambda 常与 Stream API 搭配使用处理集合：

import java.util.*;
import java.util.stream.Collectors;public class StreamQuickLook {public static void main(String[] args) {List<String> data = Arrays.asList("java", "lambda", "stream", "io");List<String> res = data.stream().filter(s -> s.length() > 2)           // 断言：保留长度大于 2 的元素.map(String::toUpperCase)               // 映射：转大写.sorted(Comparator.comparingInt(String::length)) // 排序：按长度.collect(Collectors.toList());          // 收集为新列表System.out.println(res);}
}