深入理解Java Stream

Java 8引入的Stream API是一个功能强大、灵活且可组合的流处理模式，它允许我们以一种比传统的for循环更简洁、更易于阅读和管理的方式处理数据。Stream API基于Lambda表达式和方法引用实现了一种函数式编程样式，可以将我们的程序从特定的实现中解耦出来。本篇文章将介绍Java Stream的用法和特性，旨在帮助读者更好地掌握和运用Java Stream。

一、生成Stream

Stream可以从数组、集合、文件、网络、任何对象等多种数据源生成，我们可以使用Stream的静态方法创建Stream、或者将已有的Stream处理成新的Stream，这些静态方法包括：

Stream.of(T...)
Stream.empty()
Arrays.stream(T[])
Collection.stream()

其中，Stream.of()用于将数组或任意个数的元素转换为Stream；Stream.empty()用于生成空的Stream；Arrays.stream()用于将数组转换为Stream；Collection.stream()用于将Collection转换为Stream。

二、Stream的操作

1. 中间操作

中间操作是指返回Stream类型的操作，可以被其他Stream操作链式调用，例如filter()、map()、sorted()、distinct()等。这些操作可以串接使用，我们可以在一个Stream上执行多个中间操作，以构建出一个复杂逻辑的数据流处理链。

1.1 filter()

filter()方法用于排除不符合条件的元素，该方法需要传入一个Predicate类型的Lambda表达式，该表达式接受一个参数，并返回一个boolean类型的结果，如果结果为true，则保留该元素；如果为false，则排除该元素。例如，筛选出一个整数集合中所有大于等于5的元素：

IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    .filter(num -> num >= 5)
    .forEach(System.out::println);

该代码会输出：

5
6
7
8
9
10

1.2 map()

map()方法用于将一个元素转换为另一个类型的元素，它需要传入一个Function类型的Lambda表达式，该表达式接受一个参数，并返回一个处理后的结果。例如，将一个字符串集合中所有的字符串转换为大写格式：

List list = Arrays.asList("apple", "banana", "orange");
list.stream()
    .map(String::toUpperCase)
    .forEach(System.out::println);

该代码会输出：

APPLE
BANANA
ORANGE

1.3 flatMap()

flatMap()方法可以将一个Stream中的每个对象分解为多个Stream，最后将多个Stream合成一个Stream并返回。flatMap()方法需要传入一个Function类型的Lambda表达式，该表达式接受一个参数，并返回一个Stream类型的结果。例如，取出一个集合中所有字符串的单词，并将其输出：

List list = Arrays.asList("Hello World", "Stream API");
list.stream()
    .flatMap(str -> Stream.of(str.split(" ")))
    .forEach(System.out::println);

该代码会输出：

Hello
World
Stream
API

1.4 distinct()

distinct()方法用于去重，它返回一个去除了重复元素的新Stream。如果集合元素没有重写equals()和hashCode()方法，则该方法只能使用在基本类型Stream上。例如，去除一组数字中的重复元素：

IntStream.of(1, 2, 3, 3, 4, 4, 5, 6, 6, 7, 8, 8)
    .distinct()
    .forEach(System.out::println);

该代码会输出：

1
2
3
4
5
6
7
8

1.5 sorted()

sorted()方法用于对Stream中的元素进行排序，排序时可以自定义排序规则，排序最终会返回一个新的Stream。例如，对一组数字进行排序：

IntStream.of(4, 2, 5, 1, 6, 3)
    .sorted()
    .forEach(System.out::println);

该代码会输出：

1
2
3
4
5
6

2. 终止操作

终止操作是指返回非Stream类型的操作，它们将Stream管道处理后的结果输出或返回。在一个Stream管道中，只有一个终止操作才会触发流动处理，终止操作是Stream管道处理的必要环节。终止操作包括：

• forEach()
• count()
• findFirst()
• reduce()
• toArray()
• collect()

2.1 forEach()

forEach()方法用于遍历Stream中的元素，它会接收一个Consumer类型的Lambda表达式作为参数，该表达式接受一个参数，并没有返回值。例如，遍历一个整数集合并输出其平方：

IntStream.of(1, 2, 3, 4, 5)
    .forEach(num -> System.out.println(num * num));

该代码会输出：

1
4
9
16
25

2.2 count()

count()方法用于计算Stream中元素的个数，返回一个long类型的结果。例如，计算一组数字的个数：

long count = IntStream.of(1, 2, 3, 4, 5).count();
System.out.println("count: " + count);

该代码将输出：

count: 5

2.3 findFirst()

findFirst()方法用于查找Stream中第一个符合条件的元素，返回一个Optional类型的结果。例如，查找一组字符串中第一个以大写字母开头的元素：

List list = Arrays.asList("a", "b", "C", "d");
Optional firstUpper = list.stream().filter(str -> Character.isUpperCase(str.charAt(0))).findFirst();
System.out.println("first upper: " + firstUpper.orElse("not found"));

该代码将输出：

first upper: C

2.4 reduce()

reduce()方法用于对Stream中的所有元素进行“累加”处理，并返回处理结果。reduce()方法需要传入两个参数，第一个参数是初始值，第二个参数是一个BinaryOperator类型的Lambda表达式，该表达式接收两个同类型的参数，并返回一个同类型的结果。例如，计算一组数字的和：

int sum = IntStream.of(1, 2, 3, 4, 5).reduce(0, (a, b) -> a + b);
System.out.println("sum: " + sum);

该代码将输出：

sum: 15

2.5 toArray()

toArray()方法用于将Stream生成一个数组，返回一个T[]类型的结果。例如，将集合中所有的元素保存到数组中：

List list = Arrays.asList("a", "b", "c");
String[] arr = list.stream().toArray(String[]::new);
System.out.println("array: " + Arrays.toString(arr));

该代码将输出：

array: [a, b, c]

2.6 collect()

collect()方法是非常重要的一个操作，它可以将Stream中的所有元素按照指定的方式收集起来，可以选取任何类型的集合、Map、数组，或者自定义的Collector进行收集操作。例如，将一组字符串拼接为一个字符串：

List list = Arrays.asList("a", "b", "c");
String str = list.stream().collect(Collectors.joining("-"));
System.out.println("merged string: " + str);

该代码将输出：

merged string: a-b-c

三、并行处理与性能

Stream API支持并行处理，可以让程序利用多核CPU的优势，提高数据处理性能。我们可以通过parallel()方法将一个Stream切换为并行流，或者通过sequential()方法将并行流切换为顺序流。例如，计算一组整数的平方和：

long start = System.currentTimeMillis();
int result = IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
                      .parallel() // 切换为并行流
                      .map(num -> num * num)
                      .reduce(0, (a, b) -> a + b);
long end = System.currentTimeMillis();
System.out.println("result: " + result);
System.out.println("time used: " + (end - start) + "ms");

该代码将输出：

result: 385
time used: 11ms

当然，并不是所有情况都适合使用并行流，可能会存在以下问题：

• 数据量较小：并行流的创建和销毁需要一定的时间，当数据量很小时，顺序流可能会更快。
• 有些操作不适合并行处理：例如排序和去重。
• 有些操作需要先完成一部分才能进行下一步操作：例如findFirst()。

四、结束语

Java Stream API是Java 8引入的重要特性之一，虽然Stream看起来很复杂，但实际上它是与函数式编程思想一脉相承的，它可以帮助我们更好地编写与数据处理相关的代码。本文介绍了Stream的基本用法、操作类型和并行处理特性，希望能够帮助读者更好地掌握和运用Java Stream API。