Java 函数式编程
函数式编程的意义
函数式编程理念强调函数纯粹性和不可变性，这有助于写出更稳定、更易测试的代码，尤其在并发环境下减少 bug
lambda 表达式
import java.util.function.Function;public class Strategize {Function<String, String> getString = h -> h + "hello";public static void main(String[] args) {Strategize s = new Strategize();System.out.println(s.getString.apply("Hi, "));}
}
与匿名内部类相比，lambda 表达式通常可读性更好。
方法引用
Java 方法引用（Method Reference）是 Lambda 表达式的一种简洁写法，用于直接引用已有的方法，使代码更加清晰、简洁
interface Callable {void call(String s);
}class Describe {void show(String msg) {System.out.println(msg);}
}public class MethodReferences {static void hello(String name) {System.out.println("Hello " + name);}static class Description {String about;Description(String desc) {about = desc;}void help(String msg) {System.out.println(about + " " + msg);}}static class Helper {static void assist(String msg) {System.out.println(msg);}}public static void main(String[] args) {Describe d = new Describe();Callable c = d::show;c.call("call()");c = MethodReferences::hello;c.call("bob");c = new Description("valuable")::help;c.call("information");c = Helper::assist;c.call("Help");}
}
函数式接口
Rubbable 接口
Runnable 是 Java 中最经典的函数式接口之一，用于表示一个“无参、无返回值”的任务，通常用于线程执行
public class Work {public static void doWork() {System.out.println("工作进行中！");}public static void main(String[] args) {Runnable task = Work::doWork;new Thread(task).start();}
}
单一抽象方法注解
接口中只能有一个抽象方法。这样的接口被称为函数式接口，是 Lambda 表达式可以使用的基础。
@FunctionalInterface
interface AnotherBadInterface {void doA();void doB();
}
@FunctionalInterface注解，当接口定义的方法非单一，编译报错
闭包
Java 中的闭包是通过 Lambda 表达式实现的，它允许函数访问其定义时的作用域变量，但要求这些变量是不可变的（effectively final），以保证线程安全与稳定性
public class ClosureExample {public static void main(String[] args) {int x = 10;Runnable r = () -> {System.out.println("x = " + x); // 捕获了外部变量 x};r.run(); // 输出 x = 10}
}
变量默认是 final
int x = 10;
x = 20; // ❌ 编译错误
Runnable r = () -> System.out.println(x); // 会报错
可以修改捕获对象的字段，但不能重新赋值变量
class Box {int value = 10;
}public class ClosureDemo {public static void main(String[] args) {Box box = new Box();Runnable r = () -> {box.value = 99; // ✅ 允许修改对象字段};r.run();System.out.println(box.value); // 输出 99// box = new Box(); // ❌ 不允许重新赋值}
}
Java 闭包的工作原理（底层理解）
Java 编译器会将 Lambda 表达式 编译成一个匿名内部类 或 方法句柄（在 JVM 层面优化），并将捕获的变量以常量或构造函数参数的形式传入
所以你看到的是“捕获变量”，实际上 Lambda 拿到的是 复制进去的值或引用，但不允许修改其指向
函数组合
在 Java 中，函数组合（Function Composition） 是函数式编程的一个强大能力，允许你将多个函数合并成一个新函数，以更简洁优雅的方式处理数据
多个方法
| 组合方式 | 含义 |
|---|---|
f.andThen(g) | 先执行 f，再执行 g（即 g(f(x))） |
f.compose(g) | 先执行 g，再执行 f（即 f(g(x))） |
predicate.and() | 逻辑与，组合两个条件为：条件1 且 条件2 |
predicate.or() | 逻辑或，组合两个条件为：条件1 或 条件2 |
predicate.negate() | 条件取反，等价于 !predicate.test(x) |
示例 1
import java.util.function.Function;public class FunctionComposeDemo {public static void main(String[] args) {Function<Integer, Integer> f = x -> x + 2;Function<Integer, Integer> g = x -> x * 3;// h(x) = g(f(x)) = (x + 2) * 3Function<Integer, Integer> h = f.andThen(g);// k(x) = f(g(x)) = (x * 3) + 2Function<Integer, Integer> k = f.compose(g);System.out.println("h(4) = " + h.apply(4)); // (4 + 2) * 3 = 18System.out.println("k(4) = " + k.apply(4)); // (4 * 3) + 2 = 14}
}
示例 2
Predicate<String> notEmpty = s -> !s.isEmpty();
Predicate<String> startsWithA = s -> s.startsWith("A");Predicate<String> complex = notEmpty.and(startsWithA);System.out.println(complex.test("Apple")); // true
System.out.println(complex.test("")); // false