Java中实现函数式编程的几种方法

### Java中实现函数式编程的几种方法

#### 1. Lambda表达式

Lambda表达式是Java 8引入的核心特性，用于简化匿名内部类的写法。其基本语法为`(参数) -> 表达式`或`(参数) -> {语句块}`。

应用场景：

- 替代单方法接口

- 简化集合遍历

- 事件处理

代码示例：

```java

// 传统方式

Runnable task1 = new Runnable() {

@Override

public void run() {

System.out.println(传统方式);

}

};

// Lambda方式

Runnable task2 = () -> System.out.println(Lambda方式);

// 带参数的Lambda

Function parser = s -> Integer.parseInt(s);

```

#### 2. 方法引用

方法引用通过`::`运算符直接调用已有方法，进一步简化代码。

四种引用类型：

- 静态方法引用：`ClassName::staticMethod`

- 实例方法引用：`instance::method`

- 类实例方法引用：`ClassName::instanceMethod`

- 构造器引用：`ClassName::new`

代码示例：

```java

// 静态方法引用

Function parseInt = Integer::parseInt;

// 实例方法引用

List list = Arrays.asList(a, b, c);

list.forEach(System.out::println);

// 构造器引用

Supplier> listSupplier = ArrayList::new;

```

#### 3. 函数式接口

函数式接口是仅包含一个抽象方法的接口，可用`@FunctionalInterface`注解标记。

常用函数式接口：

- `Function`：接收T类型参数，返回R类型结果

- `Predicate`：接收T类型参数，返回boolean

- `Consumer`：接收T类型参数，无返回值

- `Supplier`：无参数，返回T类型结果

代码示例：

```java

@FunctionalInterface

interface StringProcessor {

String process(String input);

}

// 自定义函数式接口使用

StringProcessor upperCase = s -> s.toUpperCase();

StringProcessor addPrefix = s -> Prefix_ + s;

System.out.println(upperCase.process(hello)); // 输出: HELLO

```

#### 4. Stream API

Stream API提供声明式数据处理能力，支持链式操作。

核心操作：

- 中间操作：filter、map、sorted

- 终端操作：collect、forEach、reduce

代码示例：

```java

List names = Arrays.asList(Alice, Bob, Charlie, David);

// 链式操作

List result = names.stream()

.filter(name -> name.length() > 3)

.map(String::toUpperCase)

.sorted()

.collect(Collectors.toList());

// 并行流处理

long count = names.parallelStream()

.filter(name -> name.startsWith(A))

.count();

```

#### 5. Optional类

Optional提供更安全的空值处理方式，避免NullPointerException。

常用方法：

- `ofNullable()`：创建可能为空的Optional

- `orElse()`：提供默认值

- `ifPresent()`：值存在时执行操作

代码示例：

```java

Optional optional = Optional.ofNullable(getName());

// 传统空值检查

if (optional.isPresent()) {

System.out.println(optional.get());

}

// 函数式风格

optional.ifPresent(System.out::println);

String result = optional.orElse(Default);

```

#### 6. 组合函数

通过`andThen`和`compose`方法实现函数组合。

代码示例：

```java

Function multiply = x -> x 2;

Function add = x -> x + 3;

// 组合函数：先乘后加

Function composed = multiply.andThen(add);

System.out.println(composed.apply(5)); // 输出: 13

// 组合函数：先加后乘

Function composed2 = multiply.compose(add);

System.out.println(composed2.apply(5)); // 输出: 16

```

#### 7. 柯里化

通过函数分解实现柯里化，将多参数函数转换为一系列单参数函数。

代码示例：

```java

// 传统多参数函数

Function> adder = x -> y -> x + y;

// 柯里化应用

Function add5 = adder.apply(5);

System.out.println(add5.apply(3)); // 输出: 8

// 三参数柯里化示例

Function>>

curried = a -> b -> c -> a + b + c;

int result = curried.apply(1).apply(2).apply(3); // 输出: 6

```

#### 实践建议

1. 优先使用不可变对象和纯函数

2. 合理选择Stream操作，避免过度使用

3. 注意Lambda表达式的变量捕获规则

4. 适时使用方法引用提升代码可读性

5. 结合设计模式使用函数式特性

这些方法共同构成了Java函数式编程的核心能力，通过合理组合使用，可以显著提升代码的简洁性和可维护性。