### Java函数式编程Lambda表达式与StreamAPI实战指南

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

1. 基本语法

```java

(parameters) -> expression

(parameters) -> { statements; }

```

2. 常见用法示例

```java

// 替代匿名内部类

Runnable task = () -> System.out.println(运行任务);

new Thread(task).start();

// 集合排序

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

Collections.sort(names, (a, b) -> a.compareTo(b));

// 事件处理

button.addActionListener(e -> System.out.println(按钮被点击));

```

#### 二、函数式接口应用

1. 内置函数式接口

```java

// Predicate - 条件判断

Predicate lengthCheck = s -> s.length() > 5;

boolean result = lengthCheck.test(Hello World);

// Function - 数据转换

Function stringToInt = Integer::parseInt;

Integer number = stringToInt.apply(123);

// Consumer - 消费数据

Consumer printer = System.out::println;

printer.accept(Hello Lambda);

// Supplier - 数据提供

Supplier randomSupplier = Math::random;

Double randomValue = randomSupplier.get();

```

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

1. 创建Stream

```java

// 从集合创建

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

Stream stream1 = list.stream();

// 从数组创建

String[] array = {a, b, c};

Stream stream2 = Arrays.stream(array);

// 使用Stream.of

Stream stream3 = Stream.of(a, b, c);

// 生成无限流

Stream infiniteStream = Stream.iterate(0, n -> n + 1);

```

2. 中间操作

```java

List words = Arrays.asList(apple, banana, cherry, date);

// filter - 过滤

List longWords = words.stream()

.filter(word -> word.length() > 5)

.collect(Collectors.toList());

// map - 转换

List wordLengths = words.stream()

.map(String::length)

.collect(Collectors.toList());

// sorted - 排序

List sortedWords = words.stream()

.sorted(Comparator.reverseOrder())

.collect(Collectors.toList());

// distinct - 去重

List uniqueWords = words.stream()

.distinct()

.collect(Collectors.toList());

```

3. 终端操作

```java

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// collect - 收集结果

List evenNumbers = numbers.stream()

.filter(n -> n % 2 == 0)

.collect(Collectors.toList());

// forEach - 遍历

numbers.stream()

.filter(n -> n > 5)

.forEach(System.out::println);

// reduce - 归约

Optional sum = numbers.stream()

.reduce(Integer::sum);

// count - 计数

long count = numbers.stream()

.filter(n -> n % 2 == 0)

.count();

```

#### 四、实战案例

1. 数据处理示例

```java

public class EmployeeProcessor {

private List employees;

public EmployeeProcessor(List employees) {

this.employees = employees;

}

// 获取高薪员工

public List getHighSalaryEmployees(double threshold) {

return employees.stream()

.filter(emp -> emp.getSalary() > threshold)

.sorted((e1, e2) -> Double.compare(e2.getSalary(), e1.getSalary()))

.collect(Collectors.toList());

}

// 按部门分组

public Map> groupByDepartment() {

return employees.stream()

.collect(Collectors.groupingBy(Employee::getDepartment));

}

// 统计部门薪资

public Map getDepartmentSalaryStats() {

return employees.stream()

.collect(Collectors.groupingBy(

Employee::getDepartment,

Collectors.averagingDouble(Employee::getSalary)

));

}

}

```

2. 文件处理示例

```java

public class FileProcessor {

// 读取文件并处理

public void processFile(String filePath) throws IOException {

List lines = Files.lines(Paths.get(filePath))

.filter(line -> !line.trim().isEmpty())

.map(String::toUpperCase)

.collect(Collectors.toList());

// 写入处理后的内容

Files.write(Paths.get(output.txt), lines);

}

// 统计单词频率

public Map wordFrequency(String text) {

return Arrays.stream(text.split(\W+))

.filter(word -> !word.isEmpty())

.map(String::toLowerCase)

.collect(Collectors.groupingBy(

Function.identity(),

Collectors.counting()

));

}

}

```

3. 集合操作优化

```java

public class CollectionOptimizer {

// 并行流处理大数据集

public void processLargeDataset(List dataset) {

List results = dataset.parallelStream()

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

.map(this::processData)

.collect(Collectors.toList());

}

// 链式操作优化

public Optional findOptimalValue(List values) {

return values.stream()

.filter(this::isValid)

.max(Comparator.comparing(String::length)

.thenComparing(String::compareTo));

}

}

```

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

1. 避免在流中执行耗时操作

```java

// 不推荐

list.stream().map(item -> {

// 耗时操作

return processItem(item);

});

// 推荐使用并行流

list.parallelStream().map(item -> processItem(item));

```

2. 合理使用短路操作

```java

// 使用findFirst而不是filter().collect()获取第一个匹配项

Optional result = list.stream()

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

.findFirst();

```

3. 避免不必要的装箱操作

```java

// 使用原始类型流提高性能

IntStream.range(0, 1000)

.filter(i -> i % 2 == 0)

.sum();

```

#### 六、最佳实践

1. 保持Lambda表达式简洁

2. 使用方法引用提升可读性

3. 合理使用并行流

4. 注意异常处理

5. 避免在Lambda中修改外部状态

通过掌握Lambda表达式和Stream API，可以显著提升Java代码的简洁性和可维护性，同时利用函数式编程的特性编写出更高效、更易读的代码。