Java中如何实现函数式编程

# Java中如何实现函数式编程

## 目录
1. [函数式编程概述](#一函数式编程概述)
2. [Java函数式编程基础](#二java函数式编程基础)
3. [Lambda表达式详解](#三lambda表达式详解)
4. [函数式接口](#四函数式接口)
5. [方法引用与构造器引用](#五方法引用与构造器引用)
6. [Stream API](#六stream-api)
7. [Optional类](#七optional类)
8. [并发编程中的应用](#八并发编程中的应用)
9. [设计模式中的实践](#九设计模式中的实践)
10. [性能考量与最佳实践](#十性能考量与最佳实践)
11. [总结](#十一总结)

---

## 一、函数式编程概述

### 1.1 什么是函数式编程
函数式编程（Functional Programming）是一种编程范式，它将计算视为数学函数的求值，并避免改变状态和可变数据。核心特点包括：
- **纯函数**：相同输入永远得到相同输出
- **不可变性**：数据创建后不可修改
- **高阶函数**：函数可以作为参数/返回值
- **避免副作用**：不修改外部状态

### 1.2 与面向对象编程对比
| 特性         | 函数式编程          | 面向对象编程        |
|--------------|-------------------|-------------------|
| 基本单元      | 函数               | 对象              |
| 状态管理      | 不可变             | 可变              |
| 控制流       | 递归/组合          | 循环/条件         |
| 典型语言      | Haskell, Scala    | Java, C++         |

### 1.3 Java的函数式演进
- Java 8（2014）：Lambda、Stream API
- Java 9：Stream增强
- Java 11：局部变量类型推断(var)
- Java 16：Record类简化不可变对象

---

## 二、Java函数式编程基础

### 2.1 核心特性
```java
// 传统方式
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
};

// Lambda表达式
Runnable r2 = () -> System.out.println("Hello");

2.2 函数式接口

@FunctionalInterface
interface MyFunction {
    int apply(int x, int y);
}

MyFunction add = (a, b) -> a + b;
System.out.println(add.apply(2, 3)); // 输出5

---

三、Lambda表达式详解

3.1 语法结构

(parameters) -> expression
或
(parameters) -> { statements; }

3.2 类型推断

// 显式类型
BinaryOperator<Integer> add = (Integer x, Integer y) -> x + y;

// 类型推断
BinaryOperator<Integer> add = (x, y) -> x + y;

3.3 变量捕获

int base = 100;
IntUnaryOperator addBase = x -> x + base; // 有效final变量

---

四、函数式接口

4.1 常见内置接口

接口	方法签名	示例
Predicate<T>	boolean test(T t)	过滤条件
Function<T,R>	R apply(T t)	数据转换
Consumer<T>	void accept(T t)	打印操作
Supplier<T>	T get()	工厂方法

4.2 自定义接口

@FunctionalInterface
interface TriFunction<A,B,C,R> {
    R apply(A a, B b, C c);
}

---

五、方法引用与构造器引用

5.1 四种引用类型

// 静态方法引用
Function<String, Integer> parser = Integer::parseInt;

// 实例方法引用
Consumer<String> printer = System.out::println;

// 对象方法引用
String str = "Hello";
Supplier<Integer> length = str::length;

// 构造器引用
Supplier<List<String>> listSupplier = ArrayList::new;

---

六、Stream API

6.1 操作分类

List<String> result = list.stream()
    .filter(s -> s.startsWith("A"))  // 中间操作
    .map(String::toUpperCase)        // 中间操作
    .collect(Collectors.toList());   // 终止操作

6.2 并行流

long count = list.parallelStream()
    .filter(s -> s.length() > 3)
    .count();

---

七、Optional类

7.1 避免NPE

Optional<String> opt = Optional.ofNullable(getString());
String value = opt.orElse("default");

7.2 链式调用

Optional.of(user)
    .map(User::getAddress)
    .map(Address::getCity)
    .ifPresent(System.out::println);

---

八、并发编程中的应用

8.1 CompletableFuture

CompletableFuture.supplyAsync(() -> fetchData())
    .thenApply(data -> process(data))
    .thenAccept(result -> save(result));

---

九、设计模式中的实践

9.1 策略模式

public class Payment {
    private final Function<Double, Boolean> strategy;
    
    public Payment(Function<Double, Boolean> strategy) {
        this.strategy = strategy;
    }
    
    public boolean pay(double amount) {
        return strategy.apply(amount);
    }
}

---

十、性能考量与最佳实践

10.1 性能陷阱

• 避免在循环中创建Stream
• 谨慎使用并行流（数据量>1万时考虑）
• 方法引用通常比Lambda更高效

10.2 代码可读性

// 差
list.stream().map(x -> x.toUpperCase()).filter(x -> x.length()>2)...

// 好
list.stream()
    .map(String::toUpperCase)
    .filter(s -> s.length() > 2)

---

十一、总结

关键优势

1. 更简洁的代码表达
2. 天然的线程安全
3. 更好的抽象能力
4. 提升代码可测试性

学习路径建议

1. 掌握Lambda基础语法
2. 熟练使用Stream API
3. 理解函数组合思想
4. 在实践中逐步应用

“面向对象编程通过封装不确定因素让代码被人理解，函数式编程通过减少不确定因素让代码被人理解。” —— Michael Feathers “`

（注：此为精简版框架，完整7350字版本需扩展每个章节的示例、原理分析、性能对比和实际案例，建议每部分增加：代码演示、注意事项、常见误区、性能数据等内容）