Java 8 中的 Stream：强大的函数式编程工具

简介

Java 8 引入了 Stream API，这是一个用于处理集合数据的强大工具，它提供了一种声明式的方式来处理数据集合，允许你以函数式编程的风格进行数据处理，避免了传统的命令式编程风格中繁琐的循环和状态管理。Stream API 使得代码更加简洁、易读，并且能够充分利用多核处理器的优势进行并行处理。

目录

1. 基础概念
2. 使用方法
   • 创建 Stream
   • 中间操作
   • 终端操作
3. 常见实践
   • 过滤数据
   • 映射数据
   • 查找与匹配
   • 归约操作
4. 最佳实践
   • 并行 Stream 的合理使用
   • 避免不必要的中间操作
   • 结合方法引用简化代码
5. 小结
6. 参考资料

基础概念

Stream 是 Java 8 中引入的一个接口，它代表了一组支持顺序和并行聚合操作的元素序列。与集合不同，Stream 并不存储数据，而是在数据来源（如集合、数组等）上进行操作。Stream 操作通常是链式调用的，并且分为中间操作和终端操作。 - 中间操作：返回一个新的 Stream，允许对 Stream 进行一系列的操作，如过滤、映射等。中间操作是惰性求值的，即只有在终端操作执行时才会真正执行。 - 终端操作：执行 Stream 上的操作，并返回一个结果。终端操作会触发 Stream 的求值，使所有中间操作依次执行。

使用方法

创建 Stream

1. 从集合创建 ```java import java.util.Arrays; import java.util.List; import java.util.stream.Stream;

   public class StreamExample { public static void main(String[] args) { List numbers = Arrays.asList(1, 2, 3, 4, 5); Stream streamFromList = numbers.stream(); Stream parallelStreamFromList = numbers.parallelStream(); } } 2. **从数组创建**java int[] array = {1, 2, 3, 4, 5}; IntStream streamFromArray = Arrays.stream(array); 3. **使用 Stream.of() 方法**java Stream streamFromString = Stream.of("apple", "banana", "cherry"); ```

中间操作

1. 过滤（filter）：根据条件过滤 Stream 中的元素。 java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); Stream<Integer> filteredStream = numbers.stream() .filter(number -> number % 2 == 0);
2. 映射（map）：将 Stream 中的每个元素映射为另一个元素。 java List<String> words = Arrays.asList("apple", "banana", "cherry"); Stream<Integer> lengthStream = words.stream() .map(String::length);
3. 排序（sorted）：对 Stream 中的元素进行排序。 java List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5); Stream<Integer> sortedStream = numbers.stream() .sorted();

终端操作

1. 遍历（forEach）：对 Stream 中的每个元素执行给定的操作。 java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); numbers.stream() .forEach(System.out::println);
2. 收集（collect）：将 Stream 中的元素收集到一个集合中。 java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); List<Integer> evenNumbers = numbers.stream() .filter(number -> number % 2 == 0) .collect(Collectors.toList());
3. 归约（reduce）：将 Stream 中的元素组合成一个值。 java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); Optional<Integer> sum = numbers.stream() .reduce((a, b) -> a + b);

常见实践

过滤数据

在处理数据时，经常需要根据某些条件过滤出符合要求的元素。例如，从一个员工列表中筛选出年龄大于 30 岁的员工：

import java.util.List;
import java.util.stream.Collectors;

class Employee {
    private String name;
    private int age;

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }
}

public class FilterExample {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
                new Employee("Alice", 25),
                new Employee("Bob", 35),
                new Employee("Charlie", 40)
        );

        List<Employee> filteredEmployees = employees.stream()
              .filter(employee -> employee.getAge() > 30)
              .collect(Collectors.toList());

        filteredEmployees.forEach(employee -> System.out.println(employee.getName()));
    }
}

映射数据

将一种类型的数据转换为另一种类型是常见的需求。例如，将一个字符串列表中的每个字符串转换为大写：

import java.util.List;
import java.util.stream.Collectors;

public class MapExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        List<String> upperCaseWords = words.stream()
              .map(String::toUpperCase)
              .collect(Collectors.toList());

        upperCaseWords.forEach(System.out::println);
    }
}

查找与匹配

查找 Stream 中是否存在满足特定条件的元素，或者查找第一个满足条件的元素。例如，判断一个整数列表中是否存在偶数：

import java.util.List;

public class FindAndMatchExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 3, 5, 7, 9);
        boolean existsEven = numbers.stream()
              .anyMatch(number -> number % 2 == 0);

        System.out.println("Exists even number: " + existsEven);
    }
}

归约操作

归约操作可以将 Stream 中的元素合并成一个单一的值。例如，计算一个整数列表的总和：

import java.util.List;

public class ReduceExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.stream()
              .reduce(0, (a, b) -> a + b);

        System.out.println("Sum: " + sum);
    }
}

最佳实践

并行 Stream 的合理使用

并行 Stream 可以充分利用多核处理器的优势，提高数据处理的效率。但是，并不是所有情况下都适合使用并行 Stream。在使用并行 Stream 时，需要考虑以下几点： - 数据量：对于小数据量，并行处理的开销可能会超过其带来的性能提升。 - 操作复杂度：如果 Stream 上的操作非常简单，并行处理的开销可能会大于实际的处理时间。 - 数据独立性：并行 Stream 中的元素处理应该是相互独立的，否则可能会导致数据竞争和不一致的结果。

避免不必要的中间操作

中间操作是惰性求值的，但过多的中间操作可能会增加代码的复杂性和性能开销。尽量将多个中间操作合并成一个更高效的操作。例如，避免多次调用 filter 和 map，可以尝试将它们合并成一个操作。

结合方法引用简化代码

方法引用是 Java 8 中的一个强大特性，它可以使代码更加简洁和易读。在 Stream 操作中，尽量使用方法引用代替匿名函数。例如，使用 Integer::sum 代替 (a, b) -> a + b。

小结

Java 8 的 Stream API 为处理集合数据提供了一种简洁、高效的方式。通过理解 Stream 的基础概念、掌握常见的使用方法和最佳实践，开发者可以编写出更加清晰、易维护的代码。Stream API 的引入不仅提升了开发效率，还使得 Java 能够更好地支持函数式编程范式。

参考资料

• Oracle Java 8 Documentation - Stream API
• Effective Java, Third Edition - Chapter 7: Lambdas and Streams
• Java 8 in Action