### Java函数式编程：Lambda表达式与StreamAPI的实战应用

#### 一、Lambda表达式基础应用

1. 替代匿名内部类

```java

// 传统写法

new Thread(new Runnable() {

@Override

public void run() {

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

}

}).start();

// Lambda写法

new Thread(() -> System.out.println(Lambda方式)).start();

```

2. 集合遍历优化

```java

List list = Arrays.asList(Java, Python, C++);

// 传统foreach

for (String s : list) {

System.out.println(s);

}

// Lambda表达式

list.forEach(s -> System.out.println(s));

// 方法引用

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

```

#### 二、Stream API核心操作

1. 数据过滤与转换

```java

List users = getUserList();

// 过滤年龄大于18岁的用户并提取姓名

List names = users.stream()

.filter(user -> user.getAge() > 18)

.map(User::getName)

.collect(Collectors.toList());

```

2. 数值统计与计算

```java

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

// 求和

int sum = numbers.stream().reduce(0, Integer::sum);

// 求最大值

Optional max = numbers.stream().max(Integer::compare);

// 平均值

Double average = numbers.stream()

.mapToInt(Integer::intValue)

.average()

.orElse(0.0);

```

#### 三、实战应用场景

1. 数据分组处理

```java

// 按部门分组统计薪资

Map departmentSalary = employees.stream()

.collect(Collectors.groupingBy(

Employee::getDepartment,

Collectors.averagingDouble(Employee::getSalary)

));

```

2. 复杂数据筛选

```java

// 多条件筛选和排序

List validOrders = orders.stream()

.filter(order -> order.getStatus() == OrderStatus.COMPLETED)

.filter(order -> order.getAmount() > 1000)

.sorted(Comparator.comparing(Order::getCreateTime).reversed())

.limit(10)

.collect(Collectors.toList());

```

3. 并行流处理

```java

// 大数据量并行处理

List result = bigDataList.parallelStream()

.filter(data -> data.isValid())

.map(this::processData)

.collect(Collectors.toList());

```

#### 四、性能优化技巧

1. 避免重复计算

```java

// 错误写法：重复调用耗时方法

List result = list.stream()

.filter(s -> expensiveOperation(s))

.map(s -> expensiveOperation(s))

.collect(Collectors.toList());

// 正确写法

List result = list.stream()

.map(s -> new AbstractMap.SimpleEntry<>(s, expensiveOperation(s)))

.filter(entry -> entry.getValue() != null)

.map(Entry::getKey)

.collect(Collectors.toList());

```

2. 适时使用并行流

```java

// 数据量较大时使用并行流

if (dataList.size() > 10000) {

return dataList.parallelStream()

.map(this::process)

.collect(Collectors.toList());

} else {

return dataList.stream()

.map(this::process)

.collect(Collectors.toList());

}

```

#### 五、最佳实践建议

1. 保持Lambda简洁：复杂逻辑应提取为独立方法

2. 注意异常处理：在Lambda中妥善处理受检异常

3. 避免状态修改：遵循函数式编程的无状态原则

4. 合理使用Optional：避免空指针异常

通过合理运用Lambda表达式和Stream API，可以显著提升代码的可读性和维护性，同时利用并行流特性还能优化程序性能。在实际开发中，应根据具体场景选择最适合的函数式编程方式。