Java Stream API详解#

什么是Stream API？#

Stream API是Java 8引入的一个新特性，它提供了一种声明式的方式来处理集合数据。Stream API允许我们以函数式编程的风格对集合进行操作，包括过滤、映射、排序、归约等。

Stream API的核心概念#

1. Stream#

Stream是一个数据流，它可以从集合、数组或其他数据源生成。Stream不是数据结构，它只是一个操作管道，用于处理数据。

2. 操作类型#

Stream API的操作分为两类：

中间操作：返回一个新的Stream，可以链式调用多个中间操作
终端操作：返回一个结果或副作用，触发实际的计算

3. 惰性求值#

Stream的中间操作是惰性求值的，只有当执行终端操作时，才会触发实际的计算。

4. 无状态和有状态操作#

无状态操作：每个元素的处理不依赖于之前的元素，如map、filter
有状态操作：每个元素的处理依赖于之前的元素，如sorted、distinct

5. 并行Stream#

Stream API支持并行处理，可以通过parallel()方法将Stream转换为并行Stream。

Stream API的基本操作#

1. 创建Stream#

1.1 从集合创建#

1
List<String> list = Arrays.asList("a", "b", "c");
2
Stream<String> stream = list.stream();
3

4
// 并行Stream
5
Stream<String> parallelStream = list.parallelStream();

1.2 从数组创建#

1
String[] array = {"a", "b", "c"};
2
Stream<String> stream = Arrays.stream(array);
3

4
// 从数组的指定范围创建
5
Stream<String> streamRange = Arrays.stream(array, 0, 2); // 从索引0到2（不包括2）

1.3 使用Stream.of()#

1
Stream<String> stream = Stream.of("a", "b", "c");
2
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);

1.4 创建空Stream#

1
Stream<String> emptyStream = Stream.empty();

1.5 使用Stream.generate()#

1
// 生成无限Stream
2
Stream<Double> randomStream = Stream.generate(Math::random);
3

4
// 生成有限Stream
5
Stream<Double> limitedStream = randomStream.limit(5);

1.6 使用Stream.iterate()#

1
// 生成无限Stream
2
Stream<Integer> evenStream = Stream.iterate(0, n -> n + 2);
3

4
// 生成有限Stream
5
Stream<Integer> limitedStream = evenStream.limit(5);

1.7 从文件创建#

1
try (Stream<String> lines = Files.lines(Paths.get("file.txt"))) {
2
    lines.forEach(System.out::println);
3
} catch (IOException e) {
4
    e.printStackTrace();
5
}

2. 中间操作#

2.1 filter#

过滤元素，只保留满足条件的元素。

1
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
2
List<String> filteredNames = names.stream()
3
    .filter(name -> name.length() > 3)
4
    .collect(Collectors.toList());
5
System.out.println(filteredNames); // 输出: [Alice, Charlie, David]

2.2 map#

将每个元素映射到另一个元素。

1
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
2
List<Integer> nameLengths = names.stream()
3
    .map(String::length)
4
    .collect(Collectors.toList());
5
System.out.println(nameLengths); // 输出: [5, 3, 7]

2.3 flatMap#

将每个元素映射到一个Stream，然后将所有Stream连接成一个Stream。

1
List<List<String>> lists = Arrays.asList(
2
    Arrays.asList("a", "b"),
3
    Arrays.asList("c", "d"),
4
    Arrays.asList("e", "f")
5
);
6
List<String> flattenedList = lists.stream()
7
    .flatMap(List::stream)
8
    .collect(Collectors.toList());
9
System.out.println(flattenedList); // 输出: [a, b, c, d, e, f]

2.4 distinct#

去除重复元素。

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

2.5 sorted#

排序元素。

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

7
// 自定义排序
8
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
9
List<String> sortedNames = names.stream()
10
    .sorted((s1, s2) -> s2.compareTo(s1)) // 降序
11
    .collect(Collectors.toList());
12
System.out.println(sortedNames); // 输出: [Charlie, Bob, Alice]

2.6 peek#

对每个元素执行操作，但不修改Stream。

1
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
2
List<Integer> processedNumbers = numbers.stream()
3
    .peek(n -> System.out.println("Processing: " + n))
4
    .map(n -> n * 2)
5
    .peek(n -> System.out.println("Processed: " + n))
6
    .collect(Collectors.toList());
7
System.out.println(processedNumbers); // 输出: [2, 4, 6, 8, 10]

2.7 limit#

限制Stream的大小。

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

2.8 skip#

跳过前n个元素。

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

3. 终端操作#

3.1 forEach#

遍历每个元素。

1
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
2
names.stream()
3
    .forEach(System.out::println);
4
// 输出:
5
// Alice
6
// Bob
7
// Charlie

3.2 collect#

将Stream转换为集合或其他数据结构。

1
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
2

3
// 转换为List
4
List<String> collectedList = names.stream()
5
    .filter(name -> name.length() > 3)
6
    .collect(Collectors.toList());
7

8
// 转换为Set
9
Set<String> collectedSet = names.stream()
10
    .filter(name -> name.length() > 3)
11
    .collect(Collectors.toSet());
12

13
// 转换为Map
14
Map<String, Integer> nameLengthMap = names.stream()
15
    .collect(Collectors.toMap(name -> name, String::length));
16

17
// 转换为特定的集合
18
LinkedList<String> linkedList = names.stream()
19
    .collect(Collectors.toCollection(LinkedList::new));

3.3 reduce#

将Stream中的元素归约为一个值。

1
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
2

3
// 求和
4
Optional<Integer> sum = numbers.stream()
5
    .reduce((a, b) -> a + b);
6
System.out.println(sum.orElse(0)); // 输出: 15
7

8
// 求和，指定初始值
9
int sumWithInitial = numbers.stream()
10
    .reduce(0, (a, b) -> a + b);
11
System.out.println(sumWithInitial); // 输出: 15
12

13
// 求最大值
14
Optional<Integer> max = numbers.stream()
15
    .reduce(Integer::max);
16
System.out.println(max.orElse(0)); // 输出: 5
17

18
// 连接字符串
19
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
20
String joinedNames = names.stream()
21
    .reduce("", (a, b) -> a + ", " + b);
22
System.out.println(joinedNames); // 输出: , Alice, Bob, Charlie
23

24
// 更有效的字符串连接
25
String joinedNames2 = names.stream()
26
    .collect(Collectors.joining(", "));
27
System.out.println(joinedNames2); // 输出: Alice, Bob, Charlie

3.4 count#

计算Stream中元素的数量。

1
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
2
long count = names.stream()
3
    .filter(name -> name.length() > 3)
4
    .count();
5
System.out.println(count); // 输出: 3

3.5 anyMatch#

检查是否有任何元素满足条件。

1
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
2
boolean hasBob = names.stream()
3
    .anyMatch(name -> name.equals("Bob"));
4
System.out.println(hasBob); // 输出: true

3.6 allMatch#

检查是否所有元素都满足条件。

1
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
2
boolean allPositive = numbers.stream()
3
    .allMatch(n -> n > 0);
4
System.out.println(allPositive); // 输出: true

3.7 noneMatch#

检查是否没有元素满足条件。

1
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
2
boolean noneNegative = numbers.stream()
3
    .noneMatch(n -> n < 0);
4
System.out.println(noneNegative); // 输出: true

3.8 findFirst#

返回第一个元素。

1
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
2
Optional<String> first = names.stream()
3
    .findFirst();
4
System.out.println(first.orElse("No element")); // 输出: Alice

3.9 findAny#

返回任意一个元素（在并行Stream中可能更高效）。

1
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
2
Optional<String> any = names.stream()
3
    .findAny();
4
System.out.println(any.orElse("No element")); // 输出: Alice

3.10 min#

返回最小元素。

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

3.11 max#

返回最大元素。

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

高级操作#

1. 分组和分区#

1.1 groupingBy#

按指定条件分组。

1
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
2

3
// 按长度分组
4
Map<Integer, List<String>> namesByLength = names.stream()
5
    .collect(Collectors.groupingBy(String::length));
6
System.out.println(namesByLength);
7
// 输出: {3=[Bob, Eve], 4=[David], 5=[Alice], 7=[Charlie]}
8

9
// 按长度分组，然后统计数量
10
Map<Integer, Long> countByLength = names.stream()
11
    .collect(Collectors.groupingBy(String::length, Collectors.counting()));
12
System.out.println(countByLength);
13
// 输出: {3=2, 4=1, 5=1, 7=1}
14

15
// 按长度分组，然后将名字连接起来
16
Map<Integer, String> joinedByLength = names.stream()
17
    .collect(Collectors.groupingBy(String::length,
18
        Collectors.joining(", ")));
19
System.out.println(joinedByLength);
20
// 输出: {3=Bob, Eve, 4=David, 5=Alice, 7=Charlie}

1.2 partitioningBy#

按布尔条件分区，结果是一个只有两个键（true和false）的Map。

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

3
// 按奇偶分区
4
Map<Boolean, List<Integer>> partitioned = numbers.stream()
5
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));
6
System.out.println(partitioned);
7
// 输出: {false=[1, 3, 5, 7, 9], true=[2, 4, 6, 8, 10]}

2. 映射和收集#

2.1 mapping#

在收集之前对元素进行映射。

1
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
2

3
// 收集名字的长度
4
List<Integer> nameLengths = names.stream()
5
    .collect(Collectors.mapping(String::length, Collectors.toList()));
6
System.out.println(nameLengths); // 输出: [5, 3, 7]

2.2 collectingAndThen#

在收集之后对结果进行操作。

1
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
2

3
// 收集并转换为不可变列表
4
List<String> immutableList = names.stream()
5
    .collect(Collectors.collectingAndThen(
6
        Collectors.toList(),
7
        Collections::unmodifiableList
8
    ));

3. 并行Stream#

3.1 创建并行Stream#

1
// 从集合创建
2
List<String> list = Arrays.asList("a", "b", "c", "d", "e");
3
Stream<String> parallelStream = list.parallelStream();
4

5
// 从普通Stream转换
6
Stream<String> stream = list.stream();
7
Stream<String> parallelStream2 = stream.parallel();

3.2 并行Stream的使用#

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

3
// 并行求和
4
int sum = numbers.parallelStream()
5
    .reduce(0, Integer::sum);
6
System.out.println(sum); // 输出: 55
7

8
// 并行排序
9
List<Integer> sortedNumbers = numbers.parallelStream()
10
    .sorted()
11
    .collect(Collectors.toList());
12
System.out.println(sortedNumbers); // 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

3.3 并行Stream的注意事项#

并行Stream不保证元素的处理顺序
并行Stream中的操作应该是无副作用的
并行Stream可能会增加开销，对于小数据集可能不如串行Stream高效
并行Stream使用的是Fork/Join框架，默认使用的线程数是CPU核心数

4. 自定义收集器#

可以通过实现Collector接口来创建自定义收集器。

1
// 自定义收集器，收集到StringBuilder
2
Collector<String, StringBuilder, String> stringBuilderCollector = Collector.of(
3
    StringBuilder::new, // 供应者
4
    (sb, str) -> sb.append(str).append(", "), // 累加器
5
    (sb1, sb2) -> sb1.append(sb2), // 组合器
6
    sb -> sb.toString() // 完成器
7
);
8

9
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
10
String result = names.stream()
11
    .collect(stringBuilderCollector);
12
System.out.println(result); // 输出: Alice, Bob, Charlie,

Stream API的最佳实践#

1. 链式调用#

Stream API支持链式调用，应该将多个操作链接在一起，提高代码的可读性。

1
// 好的做法
2
List<String> result = names.stream()
3
    .filter(name -> name.length() > 3)
4
    .map(String::toUpperCase)
5
    .sorted()
6
    .collect(Collectors.toList());
7

8
// 不好的做法
9
Stream<String> stream = names.stream();
10
Stream<String> filteredStream = stream.filter(name -> name.length() > 3);
11
Stream<String> mappedStream = filteredStream.map(String::toUpperCase);
12
Stream<String> sortedStream = mappedStream.sorted();
13
List<String> result = sortedStream.collect(Collectors.toList());

2. 使用方法引用#

对于简单的lambda表达式，应该使用方法引用，提高代码的可读性。

1
// 好的做法
2
List<Integer> nameLengths = names.stream()
3
    .map(String::length)
4
    .collect(Collectors.toList());
5

6
// 不好的做法
7
List<Integer> nameLengths = names.stream()
8
    .map(name -> name.length())
9
    .collect(Collectors.toList());

3. 避免副作用#

Stream的操作应该是无副作用的，不应该修改外部状态。

1
// 不好的做法
2
List<Integer> result = new ArrayList<>();
3
numbers.stream()
4
    .filter(n -> n % 2 == 0)
5
    .forEach(result::add); // 有副作用
6

7
// 好的做法
8
List<Integer> result = numbers.stream()
9
    .filter(n -> n % 2 == 0)
10
    .collect(Collectors.toList()); // 无副作用

4. 选择合适的操作#

应该选择合适的Stream操作，避免不必要的计算。

1
// 好的做法（使用anyMatch，找到第一个匹配项就停止）
2
boolean hasLongName = names.stream()
3
    .anyMatch(name -> name.length() > 10);
4

5
// 不好的做法（遍历所有元素）
6
boolean hasLongName = names.stream()
7
    .filter(name -> name.length() > 10)
8
    .count() > 0;

5. 注意并行Stream的使用#

对于小数据集，串行Stream可能更高效
对于计算密集型任务，并行Stream可能更高效
对于IO密集型任务，并行Stream可能会增加开销
并行Stream中的操作应该是线程安全的

6. 处理Optional#

当使用可能返回Optional的操作时，应该适当处理Optional。

1
// 好的做法
2
Optional<String> first = names.stream()
3
    .filter(name -> name.length() > 3)
4
    .findFirst();
5
String result = first.orElse("No element");
6

7
// 或者
8
first.ifPresent(System.out::println);
9

10
// 不好的做法
11
Optional<String> first = names.stream()
12
    .filter(name -> name.length() > 3)
13
    .findFirst();
14
if (first.isPresent()) {
15
    String result = first.get();
16
    System.out.println(result);
17
}

常见陷阱#

1. 重复使用Stream#

Stream只能使用一次，使用后会被关闭。

1
// 错误的做法
2
Stream<String> stream = names.stream();
3
stream.filter(name -> name.length() > 3);
4
stream.map(String::toUpperCase); // 会抛出IllegalStateException
5

6
// 正确的做法
7
List<String> result = names.stream()
8
    .filter(name -> name.length() > 3)
9
    .map(String::toUpperCase)
10
    .collect(Collectors.toList());

2. 副作用#

Stream的操作应该是无副作用的，否则可能会导致意外的结果。

3. 并行Stream的线程安全#

并行Stream中的操作应该是线程安全的，否则可能会导致并发问题。

4. 性能问题#

对于小数据集，并行Stream可能不如串行Stream高效
过度使用Stream API可能会导致代码可读性下降

5. 内存泄漏#

无限Stream如果不使用limit等操作限制大小，可能会导致内存泄漏。

6. 错误的收集器#

使用错误的收集器可能会导致意外的结果。

总结#

Stream API是Java 8引入的一个强大特性，它提供了一种声明式的方式来处理集合数据。Stream API支持函数式编程风格，包括过滤、映射、排序、归约等操作。Stream API的中间操作是惰性求值的，只有当执行终端操作时，才会触发实际的计算。

本文介绍了Stream API的基本概念、核心操作和最佳实践。希望本文能够帮助你更好地理解和使用Stream API。

练习#

编写一个程序，使用Stream API过滤出列表中的偶数。
编写一个程序，使用Stream API将列表中的字符串转换为大写。
编写一个程序，使用Stream API计算列表中数字的总和。
编写一个程序，使用Stream API找到列表中的最大值。
编写一个程序，使用Stream API对列表中的元素进行排序。
编写一个程序，使用Stream API将列表中的元素去重。
编写一个程序，使用Stream API将列表中的元素分组。
编写一个程序，使用Stream API将列表中的元素分区。
编写一个程序，使用Stream API创建一个并行Stream并处理数据。
编写一个程序，使用Stream API从文件中读取行并处理。

溪谷回声

记录每一次探索与抵达

Java Stream API详解