Java Stream 中间处理方法的链式调用

在 Java 8 引入 Stream API 后，为集合数据的处理带来了极大的便利。Stream 允许以一种声明式的方式对数据集合进行操作，使得代码更加简洁、易读。其中，中间处理方法的链式调用是 Stream API 的一个核心特性，它让我们能够在一个 Stream 上依次执行多个中间操作，构建出复杂的数据处理流程。

Stream 概述

在深入探讨中间处理方法的链式调用之前，先来简单回顾一下 Stream。Stream 代表一系列支持顺序和并行聚合操作的元素。与集合不同，Stream 本身并不存储数据，而是在原有的数据源（如集合、数组等）上进行操作。它的操作分为中间操作和终端操作。

中间操作返回一个新的 Stream，允许我们继续在这个新的 Stream 上进行后续操作，从而形成链式调用。常见的中间操作包括 filter、map、flatMap、sorted、distinct 等。终端操作会消耗 Stream，并产生一个最终结果，如 collect、forEach、count、findFirst 等。

中间处理方法的链式调用基础

中间处理方法的链式调用允许我们将多个中间操作连接在一起，形成一个连续的处理流程。每个中间操作都会返回一个新的 Stream，使得下一个操作可以直接在这个新的 Stream 上执行。这种链式调用的方式让代码看起来更像是一个数据处理的管道，数据从一端流入，经过一系列处理步骤后从另一端流出。

例如，假设有一个整数列表，我们想要筛选出所有偶数，然后对每个偶数进行平方，最后打印结果。使用 Stream 的链式调用可以这样实现：

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

public class StreamChainExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

        List<Integer> squaredEvenNumbers = numbers.stream()
               .filter(n -> n % 2 == 0)
               .map(n -> n * n)
               .collect(Collectors.toList());

        System.out.println(squaredEvenNumbers);
    }
}

在上述代码中，首先通过 stream() 方法将 List 转换为 Stream。接着，使用 filter 方法筛选出偶数，map 方法对筛选后的偶数进行平方操作，最后通过终端操作 collect 将处理后的结果收集到一个新的 List 中。整个过程通过链式调用一气呵成，代码简洁明了。

filter 方法

filter 方法用于根据给定的条件筛选 Stream 中的元素。它接受一个 Predicate 作为参数，该 Predicate 定义了筛选条件。只有满足条件的元素才会被包含在新的 Stream 中。

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

public class FilterExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

        List<String> longNames = names.stream()
               .filter(name -> name.length() > 5)
               .collect(Collectors.toList());

        System.out.println(longNames);
    }
}

在这个例子中，filter 方法筛选出长度大于 5 的名字。filter 方法返回一个新的 Stream，其中只包含满足条件的元素，后续操作可以继续在这个新的 Stream 上进行链式调用。

map 方法

map 方法用于将 Stream 中的每个元素按照给定的映射函数进行转换。它接受一个 Function 作为参数，该 Function 定义了如何将输入元素转换为输出元素。

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

public class MapExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        List<Integer> doubledNumbers = numbers.stream()
               .map(n -> n * 2)
               .collect(Collectors.toList());

        System.out.println(doubledNumbers);
    }
}

在上述代码中，map 方法将列表中的每个整数乘以 2，生成一个新的 Stream，其中的元素是原元素的两倍。map 方法返回的新 Stream 可以继续用于后续的链式调用。

flatMap 方法

flatMap 方法与 map 方法类似，但它的作用更强大。map 方法是将每个元素映射为一个新的元素，而 flatMap 方法是将每个元素映射为一个 Stream，然后将这些 Stream 扁平化为一个单一的 Stream。

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

public class FlatMapExample {
    public static void main(String[] args) {
        List<List<Integer>> nestedLists = Arrays.asList(
                Arrays.asList(1, 2),
                Arrays.asList(3, 4),
                Arrays.asList(5, 6)
        );

        List<Integer> flatList = nestedLists.stream()
               .flatMap(List::stream)
               .collect(Collectors.toList());

        System.out.println(flatList);
    }
}

在这个例子中，nestedLists 是一个包含多个子列表的列表。flatMap 方法将每个子列表映射为一个 Stream，然后将这些 Stream 合并成一个单一的 Stream，最终收集到一个扁平的 List 中。flatMap 方法在处理嵌套结构的数据时非常有用，能够方便地将其展开为单一的 Stream 进行后续处理。

sorted 方法

sorted 方法用于对 Stream 中的元素进行排序。它有两种重载形式，一种是无参的 sorted()，会使用元素的自然顺序进行排序（前提是元素实现了 Comparable 接口）；另一种是接受一个 Comparator 的 sorted(Comparator<? super T> comparator)，可以根据自定义的比较器进行排序。

import java.util.Arrays;
import java.util.List;

public class SortedExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);

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

        System.out.println("---");

        numbers.stream()
               .sorted((a, b) -> b - a)
               .forEach(System.out::println);
    }
}

在第一个 sorted 调用中，使用自然顺序对整数进行升序排序。在第二个 sorted 调用中，通过自定义的比较器 (a, b) -> b - a 进行降序排序。sorted 方法返回一个新的 Stream，其中的元素已按指定顺序排列，方便后续操作。

distinct 方法

distinct 方法用于去除 Stream 中的重复元素。它通过使用元素的 equals 方法来判断元素是否重复。

import java.util.Arrays;
import java.util.List;

public class DistinctExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4);

        numbers.stream()
               .distinct()
               .forEach(System.out::println);
    }
}

在这个例子中，distinct 方法去除了列表中的重复整数，只保留每个不同的整数，返回一个新的 Stream，其中元素是唯一的。

peek 方法

peek 方法主要用于调试目的，它允许在 Stream 处理过程中查看每个元素。peek 方法接受一个 Consumer 作为参数，会对 Stream 中的每个元素执行该 Consumer，但不会改变元素本身。

import java.util.Arrays;
import java.util.List;

public class PeekExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        numbers.stream()
               .peek(System.out::println)
               .map(n -> n * n)
               .peek(System.out::println)
               .collect(Collectors.toList());
    }
}

在上述代码中，第一个 peek 方法在平方操作之前打印每个元素，第二个 peek 方法在平方操作之后打印每个元素。这有助于我们了解 Stream 在链式调用过程中每个步骤的中间结果，方便调试和理解代码逻辑。

limit 和 skip 方法

limit 方法用于限制 Stream 中元素的数量，只保留前 n 个元素。skip 方法则相反，它会跳过前 n 个元素，返回剩余的元素组成的 Stream。

import java.util.Arrays;
import java.util.List;

public class LimitAndSkipExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        numbers.stream()
               .limit(5)
               .forEach(System.out::println);

        System.out.println("---");

        numbers.stream()
               .skip(3)
               .forEach(System.out::println);
    }
}

在第一个例子中，limit(5) 方法只保留列表中的前 5 个元素。在第二个例子中，skip(3) 方法跳过前 3 个元素，打印剩余的元素。这两个方法在处理大数据集时非常有用，可以控制处理的数据量，提高效率。

链式调用的执行原理

当我们在 Stream 上进行链式调用时，中间操作并不会立即执行，而是会被“记录”下来。只有当终端操作被调用时，整个链式调用才会被执行，这种机制被称为“惰性求值”。

例如，考虑以下代码：

import java.util.Arrays;
import java.util.List;

public class LazyEvaluationExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        numbers.stream()
               .filter(n -> {
                    System.out.println("Filtering: " + n);
                    return n % 2 == 0;
                })
               .map(n -> {
                    System.out.println("Mapping: " + n);
                    return n * n;
                })
               .forEach(System.out::println);
    }
}

在这个例子中，filter 和 map 方法中的打印语句并不会在调用这些方法时立即执行。只有当终端操作 forEach 被调用时，才会开始执行整个链式调用。此时，filter 和 map 方法中的打印语句会按照链式调用的顺序依次执行，并且只会对最终参与终端操作的元素执行。

这种惰性求值机制带来了很多好处。首先，它可以避免不必要的计算。如果我们在链式调用中使用了 limit 方法，那么在达到指定的元素数量后，后续的操作就不会再执行。其次，惰性求值使得 Stream API 能够更好地进行优化，例如在并行流的情况下，可以更合理地分配任务，提高处理效率。

并行流与链式调用

Stream API 支持并行处理，通过调用 parallelStream() 方法可以将集合转换为并行流。在并行流中，链式调用的中间操作同样适用，但需要注意一些细节。

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

public class ParallelStreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        List<Integer> squaredNumbers = numbers.parallelStream()
               .map(n -> n * n)
               .collect(Collectors.toList());

        System.out.println(squaredNumbers);
    }
}

在并行流中，数据会被分成多个部分，每个部分由不同的线程并行处理。中间操作会并行地应用到这些数据块上，然后再将结果合并起来。需要注意的是，并行流并不总是能提高性能，尤其是在数据量较小或者中间操作的计算复杂度较低的情况下，并行处理的开销可能会超过其带来的性能提升。

另外，在并行流中使用一些中间操作时需要特别小心。例如，sorted 方法在并行流中可能会有不同的行为，因为并行处理可能会打乱元素的顺序，sorted 方法需要额外的工作来确保最终结果是有序的。

总结中间处理方法的链式调用

Java Stream 的中间处理方法的链式调用是一种强大而灵活的数据处理方式。通过将多个中间操作连接在一起，我们可以以一种简洁、声明式的方式构建复杂的数据处理流程。不同的中间操作，如 filter、map、flatMap、sorted、distinct 等，各自具有独特的功能，能够满足各种数据处理需求。

同时，理解链式调用的执行原理，包括惰性求值和并行流的特性，对于编写高效、正确的代码至关重要。合理使用中间处理方法的链式调用，可以使我们的代码更加清晰、易读，同时提高数据处理的效率。在实际开发中，根据具体的业务需求和数据特点，灵活运用这些特性，能够极大地提升我们的编程效率和代码质量。

希望通过本文的介绍，你对 Java Stream 中间处理方法的链式调用有了更深入的理解，并能够在实际项目中充分发挥其优势。