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

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

#### 1. Lambda表达式

Lambda表达式是Java 8引入的核心特性，允许以简洁的方式实现函数式接口。其语法为`(参数) -> 表达式`或`(参数) -> {语句块}`。例如：

```java

// 实现Runnable接口

Runnable task = () -> System.out.println(Running task);

new Thread(task).start();

// 使用Lambda排序

List list = Arrays.asList(apple, orange, banana);

list.sort((a, b) -> a.compareTo(b));

```

#### 2. 方法引用

方法引用通过`::`运算符简化Lambda表达式的写法，包括：

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

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

- 构造方法引用：`ClassName::new`

示例：

```java

// 静态方法引用

List numbers = Arrays.asList(1, 2, 3);

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

// 构造方法引用

Supplier> listSupplier = ArrayList::new;

```

#### 3. 函数式接口

Java提供`java.util.function`包内置四大核心函数式接口：

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

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

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

- `Predicate`：接收T类型参数，返回布尔值

示例：

```java

Function parser = Integer::parseInt;

Consumer logger = msg -> System.out.println(LOG: + msg);

Supplier randomizer = Math::random;

Predicate validator = s -> s.length() > 0;

```

#### 4. Stream API

Stream通过声明式方式处理集合数据，支持链式操作：

```java

List result = list.stream()

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

.map(String::toUpperCase)

.sorted()

.collect(Collectors.toList());

```

#### 5. Optional类

Optional提供安全的空值处理机制：

```java

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

String value = optional.orElse(default);

```

#### 6. 自定义函数式接口

通过`@FunctionalInterface`注解创建定制函数接口：

```java

@FunctionalInterface

interface TernaryOperator {

T apply(T a, T b, T c);

}

TernaryOperator max3 = (a, b, c) -> Math.max(a, Math.max(b, c));

```

#### 实际应用示例

```java

public class FunctionalExample {

public static void main(String[] args) {

// 组合使用

List data = Arrays.asList(java, python, c++);

data.stream()

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

.map(String::toUpperCase)

.forEach(System.out::println);

// 函数组合

Function multiply = x -> x 2;

Function add = x -> x + 3;

Function composed = multiply.andThen(add);

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

}

}

```

这些方式使Java能够以函数式风格编写代码，提升代码的简洁性和可读性，同时保持类型安全和性能优势。开发者可根据具体场景选择合适的方式，或组合使用多种技术实现更复杂的功能。