【Java 基础篇】Java Stream 流详解

忘是亡心i 2023-10-16 13:59 21阅读 0赞

![在这里插入图片描述][3a396b920ad84cd0a809bac5055ce06d.png]

Java Stream（流）是Java 8引入的一个强大的新特性，用于处理集合数据。它提供了一种更简洁、更灵活的方式来操作数据，可以大大提高代码的可读性和可维护性。本文将详细介绍Java Stream流的概念、用法和一些常见操作。

### 什么是Stream流？ ###

在开始介绍Java Stream流之前，让我们先了解一下什么是流。流是一系列元素的序列，它可以在一次遍历的过程中逐个处理这些元素。在Java中，流是对数据的抽象，可以操作各种不同类型的数据源，如集合、数组、文件等。

Stream流的主要特点包括：

*  **链式调用**：可以通过一系列的方法调用来定义对流的操作，使代码更具可读性。
 *  **惰性求值**：流上的操作不会立即执行，只有在遇到终端操作时才会触发计算。
 *  **函数式编程**：流操作使用了函数式编程的思想，可以通过Lambda表达式来定义操作。
 *  **并行处理**：可以轻松地将流操作并行化，充分利用多核处理器的性能。

### 创建Stream流 ###

在使用Java Stream流之前，首先需要创建一个流。流可以从各种数据源中创建，包括集合、数组、文件等。

#### 从集合创建流 ####

可以使用集合的`stream()`方法来创建一个流。例如：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
    Stream<String> stream = names.stream();

#### 从数组创建流 ####

可以使用`Arrays.stream()`方法来从数组中创建一个流。例如：

int[] numbers = {
        1, 2, 3, 4, 5};
    IntStream stream = Arrays.stream(numbers);

#### 从文件创建流 ####

可以使用`Files.lines()`方法来从文件中创建一个流。例如：

try (Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())) {
        
        // 处理文件中的每一行数据
        lines.forEach(System.out::println);
    } catch (IOException e) {
        
        e.printStackTrace();
    }

### 流的操作 ###

一旦创建了流，就可以对其进行各种操作。流的操作可以分为两类：中间操作和终端操作。

#### 中间操作 ####

中间操作是对流的一系列处理步骤，这些步骤会返回一个新的流，允许链式调用。中间操作通常用于对数据进行过滤、映射、排序等操作。一些常见的中间操作包括：

*  `filter(Predicate<T> predicate)`：根据条件过滤元素。
 *  `map(Function<T, R> mapper)`：将元素映射为新的值。
 *  `sorted()`：对元素进行排序。
 *  `distinct()`：去重，去除重复的元素。
 *  `limit(long maxSize)`：限制流中元素的数量。
 *  `skip(long n)`：跳过流中的前n个元素。

例如，以下代码将对一个整数集合进行筛选、映射和排序操作：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    List<Integer> result = numbers.stream()
        .filter(n -> n % 2 == 0) // 过滤偶数
        .map(n -> n * 2)         // 映射为原来的2倍
        .sorted()                // 排序
        .collect(Collectors.toList()); // 收集结果

#### 终端操作 ####

终端操作是流的最后一步操作，它会触发对流的计算并产生一个最终的结果。终端操作通常包括：

*  `forEach(Consumer<T> action)`：对流中的每个元素执行操作。
 *  `collect(Collector<T, A, R> collector)`：将流中的元素收集到一个容器中。
 *  `toArray()`：将流中的元素收集到数组中。
 *  `reduce(identity, accumulator)`：对流中的元素进行归约操作，返回一个值。
 *  `count()`：返回流中元素的数量。
 *  `min(comparator)`：返回流中的最小元素。
 *  `max(comparator)`：返回流中的最大元素。
 *  `allMatch(predicate)`：检查流中的所有元素是否都满足条件。
 *  `anyMatch(predicate)`：检查流中是否存在满足条件的元素。
 *  `noneMatch(predicate)`：检查流中是否没有元素满足条件。
 *  `findFirst()`：返回流中的第一个元素。
 *  `findAny()`：返回流中的任意一个元素。

终端操作是流的最后一步，一旦调用终端操作，流将被消耗，不能再被复用。

### 示例：从集合中筛选特定条件的元素 ###

让我们通过一个示例来演示Java Stream流的使用。假设我们有一个包含学生对象的集合，每个学生对象都有姓名、年龄和成绩属性。我们想从集合中筛选出年龄大于18岁且成绩优秀的学生。

class Student {
        
        private String name;
        private int age;
        private double score;
    
        public Student(String name, int age, double score) {
        
            this.name = name;
            this.age = age;
            this.score = score;
        }
    
        public String getName() {
        
            return name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public double getScore() {
        
            return score;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", score=" + score +
                    '}';
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            List<Student> students = Arrays.asList(
                new Student("Alice", 20, 90.0),
                new Student("Bob", 22, 85.5),
                new Student("Charlie", 19, 88.5),
                new Student("David", 21, 92.0),
                new Student("Eva", 18, 94.5)
            );
    
            List<Student> result = students.stream()
                .filter(student -> student.getAge() > 18 && student.getScore() >= 90.0)
                .collect(Collectors.toList());
    
            result.forEach(System.out::println);
        }
    }

运行以上代码，将输出符合条件的学生信息：

Student{name='Alice', age=20, score=90.0}
    Student{name='David', age=21, score=92.0}

### 并行流 ###

Java Stream还提供了并行流的支持，可以充分利用多核处理器的性能。只需将普通流转换为并行流，即可实现并行化处理。

List<Student> result = students.parallelStream()
        .filter(student -> student.getAge() > 18 && student.getScore() >= 90.0)
        .collect(Collectors.toList());

需要注意的是，并行流在某些情况下可能会引发线程安全问题，因此在处理共享状态时要格外小心。

### 更多操作 ###

当使用Java Stream流进行数据处理时，除了基本的过滤、映射、排序和归约等操作外，还有许多其他有用的中间操作和终端操作。在本节中，我将介绍一些常见的Stream流操作，帮助你更好地理解如何使用它们。

#### 中间操作 ####

##### 1. `distinct()` #####

`distinct()`方法用于去除流中的重复元素，返回一个去重后的新流。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
    List<Integer> distinctNumbers = numbers.stream()
        .distinct()
        .collect(Collectors.toList());
    
    System.out.println(distinctNumbers); // 输出: [1, 2, 3, 4, 5]

##### 2. `limit(n)` #####

`limit(n)`方法用于截取流中的前n个元素，返回一个包含前n个元素的新流。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    List<Integer> limitedNumbers = numbers.stream()
        .limit(5)
        .collect(Collectors.toList());
    
    System.out.println(limitedNumbers); // 输出: [1, 2, 3, 4, 5]

##### 3. `skip(n)` #####

`skip(n)`方法用于跳过流中的前n个元素，返回一个跳过前n个元素后的新流。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    List<Integer> skippedNumbers = numbers.stream()
        .skip(5)
        .collect(Collectors.toList());
    
    System.out.println(skippedNumbers); // 输出: [6, 7, 8, 9, 10]

##### 4. `flatMap()` #####

`flatMap()`方法用于将流中的每个元素映射成一个新的流，然后将这些新流合并成一个流。通常用于将嵌套的集合扁平化。

示例：

List<List<Integer>> nestedLists = Arrays.asList(
        Arrays.asList(1, 2),
        Arrays.asList(3, 4),
        Arrays.asList(5, 6)
    );
    
    List<Integer> flattenedList = nestedLists.stream()
        .flatMap(Collection::stream)
        .collect(Collectors.toList());
    
    System.out.println(flattenedList); // 输出: [1, 2, 3, 4, 5, 6]

#### 终端操作 ####

##### 1. `forEach()` #####

`forEach()`方法用于对流中的每个元素执行指定的操作。

示例：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
    names.stream()
        .forEach(name -> System.out.println("Hello, " + name));

##### 2. `toArray()` #####

`toArray()`方法用于将流中的元素收集到数组中。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    Integer[] numberArray = numbers.stream()
        .toArray(Integer[]::new);

##### 3. `reduce(identity, accumulator)` #####

`reduce()`方法用于对流中的元素进行归约操作，返回一个值。`identity`是初始值，`accumulator`是归约函数。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    int sum = numbers.stream()
        .reduce(0, (a, b) -> a + b);
    
    System.out.println(sum); // 输出: 15

##### 4. `collect()` #####

`collect()`方法用于将流中的元素收集到一个集合或其他数据结构中。可以使用`Collectors`类提供的各种工厂方法创建不同类型的集合。

示例：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
    List<String> collectedNames = names.stream()
        .collect(Collectors.toList());
    
    Set<String> collectedSet = names.stream()
        .collect(Collectors.toSet());
    
    Map<String, Integer> collectedMap = names.stream()
        .collect(Collectors.toMap(name -> name, String::length));

##### 5. `min(comparator)` 和 `max(comparator)` #####

`min(comparator)`和`max(comparator)`方法用于查找流中的最小和最大元素，需要传入一个比较器（Comparator）来定义比较规则。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    Optional<Integer> minNumber = numbers.stream()
        .min(Integer::compareTo);
    
    Optional<Integer> maxNumber = numbers.stream()
        .max(Integer::compareTo);
    
    System.out.println(minNumber.orElse(0)); // 输出: 1
    System.out.println(maxNumber.orElse(0)); // 输出: 5

##### 6. `anyMatch(predicate)`、`allMatch(predicate)` 和 `noneMatch(predicate)` #####

这些方法用于检查流中的元素是否满足给定的条件。

*  `anyMatch(predicate)`：检查流中是否有任意一个元素满足条件。
 *  `allMatch(predicate)`：检查流中的所有元素是否都满足条件。
 *  `noneMatch(predicate)`：检查流中是否没有元素满足条件。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    boolean anyGreaterThanThree = numbers.stream()
        .anyMatch(n -> n > 3);
    
    boolean allGreaterThanThree = numbers.stream()
        .allMatch(n -> n > 3);
    
    boolean noneGreaterThanTen = numbers.stream()
        .noneMatch(n -> n > 10);
    
    System.out.println(anyGreaterThanThree); // 输出: true
    System.out.println(allGreaterThanThree); // 输出: false
    System.out.println(noneGreaterThanTen);  // 输出: true

##### 7. `findFirst()` 和 `findAny()` #####

`findFirst()`方法返回流中的第一个元素（在串行流中通常是第一个元素，但在并行流中不确定），`findAny()`方法返回流中的任意一个元素。

示例：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
    Optional<String> first = names.stream()
        .findFirst();
    
    Optional<String> any = names.parallelStream()
        .findAny();

这些只是Java Stream流的一些常见操作，Stream API提供了更多的方法来处理数据。根据具体的需求，你可以组合这些操作来构建复杂的数据处理流程。希望这些示例能帮助你更好地理解和使用Java Stream流。

### 注意事项 ###

在使用Java Stream流时，有一些注意事项需要考虑，以确保代码的正确性和性能。以下是一些常见的注意事项：

1.  **不可重用性：** 一旦创建了一个Stream对象并执行了终端操作，该Stream就不能再被重用。如果需要对同一数据集进行多次处理，应该每次都创建新的Stream对象。
2.  **惰性求值：** Stream是惰性求值的，中间操作只会在终端操作触发后才会执行。这意味着中间操作不会立即产生结果，而是在需要结果时才进行计算。这可以帮助节省计算资源，但也需要谨慎处理，以免产生意外的行为。
3.  **并行流的线程安全性：** 如果使用并行流（parallelStream()），要确保Stream操作是线程安全的。一些操作可能会引发并发问题，需要适当的同步或避免使用并行流。
4.  **流的关闭：** 如果你使用的是基于IO的流（如Files.lines()），需要确保在使用完后关闭流，以释放资源。
5.  **性能注意事项：** Stream操作的性能可能会受到数据量的影响。在大数据集上使用Stream时，要注意性能问题，可以考虑使用并行流或其他优化方法。
6.  **空值处理：** 在使用Stream时，要注意空值（null）的处理，避免空指针异常。可以使用`filter`、`map`等操作来过滤或转换空值。
7.  **有状态操作：** 一些Stream操作是有状态的，例如`sorted`和`distinct`，它们可能需要缓存所有元素，因此在处理大数据集时要谨慎使用，以免导致内存溢出。
8.  **自定义收集器：** 如果需要自定义收集器（Collector），要确保它的线程安全性和正确性，以便在Stream中使用。
9.  **不可变性：** 推荐使用不可变对象和不可变集合来处理Stream，以避免并发问题。
10. **了解Stream操作的复杂度：** 不同的Stream操作具有不同的时间复杂度。了解操作的复杂度有助于选择最适合的操作来满足性能需求。

总之，使用Java Stream流可以编写更简洁和可读性强的代码，但在使用过程中需要考虑到流的惰性求值、线程安全性、性能等方面的注意事项，以确保代码的正确性和性能。

### 总结 ###

Java Stream流是一项强大的特性，可以极大地简化集合数据的处理。通过中间操作和终端操作的组合，我们可以轻松地实现各种复杂的数据处理任务。同时，流还提供了并行处理的支持，可以充分利用多核处理器的性能。

要注意的是，流是一次性的，一旦调用了终端操作，流将被消耗，不能再被复用。此外，在使用并行流时要注意线程安全的问题。

希望本文能帮助你更好地理解和使用Java Stream流，提高代码的可读性和可维护性。如果你对Java Stream流还有更多的疑问或想要深入了解，可以查阅官方文档或进一步学习相关的教程和示例。 Happy coding!

[3a396b920ad84cd0a809bac5055ce06d.png]: https://img-blog.csdnimg.cn/3a396b920ad84cd0a809bac5055ce06d.png