函数式编程（三）Stream流处理器

北纬@叶枫

已于 2023-09-01 10:42:18 修改

阅读量224

点赞数

分类专栏： java 经验分享文章标签： java 函数编程 Lambda stream

于 2023-09-01 10:40:16 首次发布

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/Farrell_zeng/article/details/132619124

版权

java 同时被 2 个专栏收录

28 篇文章 0 订阅

订阅专栏

经验分享

17 篇文章 0 订阅

订阅专栏

一、Stream概述

Stream是Java 8引入的一个用于处理集合数据的API。它提供了一种流式操作的方式，可以对集合进行过滤、映射、排序、聚合等各种操作，使得代码更加简洁、易读和易维护。

Stream的主要特点如下：

流式操作：Stream提供了一种流式操作的方式，可以对集合中的元素进行连续的操作，而不需要使用传统的循环和条件语句。
惰性求值：Stream使用惰性求值的方式，只有在终止操作时才会执行实际的计算。这样可以避免不必要的计算，提高程序的性能。
内部迭代：Stream使用内部迭代的方式，隐藏了迭代的细节，使得代码更加简洁和易读。
并行处理：Stream可以与并行计算结合使用，实现方便的并行处理，提高程序的性能。

二、Stream和Collection的区别

流（Stream）和集合（Collection）是Java中用于处理和操作数据的两种不同的概念。

数据存储方式：

- 集合是一种数据结构，用于存储和组织一组对象。它可以包含重复的元素，并且有序或无序。
- 流是一种数据处理工具，它并不存储数据，而是通过对数据进行连续的操作来产生结果。流的数据源可以是集合、数组、I/O通道等。

数据访问方式：

- 集合提供了直接访问和操作集合中元素的方法，如添加、删除、遍历等。可以通过索引或迭代器等方式访问集合中的元素。
- 流提供了一种声明式的方式来处理数据，通过连续的操作链式调用来对数据进行转换、过滤、映射等操作。流的操作是惰性求值的，只有在终止操作时才会执行实际的计算。

数据处理方式：

- 集合通常使用循环和条件语句来处理数据，需要显式地编写迭代代码。
- 流使用函数式编程的方式来处理数据，通过高阶函数和Lambda表达式来实现数据的转换和操作。可以使用丰富的中间操作和终止操作来处理数据，使得代码更加简洁和易读。

并行处理能力：

- 集合可以通过多线程来实现并行处理，但需要手动编写并发代码。
- 流提供了内置的并行处理能力，可以通过简单的调用parallel()方法将流转换为并行流，从而自动利用多核处理器进行并行计算。

总的来说，集合是一种数据结构，用于存储和组织数据，提供直接访问和操作数据的方法。而流是一种数据处理工具，通过连续的操作链式调用来对数据进行转换和操作，具有函数式编程的特性，并且支持并行处理。使用集合可以方便地存储和操作数据，而使用流可以以一种更加简洁和灵活的方式处理和操作数据。

三、Stream基本类型

以下是Java中基本类型的流类型：

IntStream：用于处理int类型的流。
LongStream：用于处理long类型的流。
DoubleStream：用于处理double类型的流。

这些基本类型的流提供了一系列的操作方法，可以直接操作对应的基本类型数据，而无需进行装箱和拆箱操作。这样可以提高性能和效率。

四、Stream函数对象

在Java的Stream API中，函数对象（Function Objects）被广泛用于对流进行转换、过滤和映射等操作。Stream API提供了一系列的函数式接口，这些接口可以作为函数对象来传递给Stream的中间操作方法。

以下是一些常用的函数式接口在Stream中的应用：

1. `Predicate`

用于判断某个条件是否满足，可以作为filter()方法的参数来过滤流中的元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Predicate<Integer> isEven = num -> num % 2 == 0;
List<Integer> evenNumbers = numbers.stream()
                                   .filter(isEven)
                                   .collect(Collectors.toList());

2. `Function<T, R>`

用于将一个类型的值转换为另一个类型的值，可以作为map()方法的参数来对流中的元素进行映射转换。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Function<String, Integer> nameLength = name -> name.length();
List<Integer> nameLengths = names.stream()
                                .map(nameLength)
                                .collect(Collectors.toList());

3. `Consumer`

用于对某个类型的值进行消费操作，可以作为forEach()方法的参数来对流中的元素进行处理。

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

4. `Supplier`

用于提供某个类型的值，可以作为generate()方法的参数来生成一个无限流。

Supplier<Integer> randomNumber = () -> new Random().nextInt(100);
Stream<Integer> randomNumbers = Stream.generate(randomNumber);
randomNumbers.limit(10)
             .forEach(System.out::println);

通过使用函数对象，我们可以以一种更加灵活和抽象的方式对流进行转换、过滤和映射等操作。函数式接口提供了一种通用的机制来定义和传递函数对象，使得代码更加简洁、可读和可维护。

五、Stream的操作分类

Stream的操作可以分为两类：中间操作和终止操作。

1.中间操作（Intermediate Operations）

是对流进行转换、过滤、映射等操作，返回一个新的流。

1.1.无状态无序操作（Stateless & Unordered Operations）

每个元素的处理是独立的，不依赖于其他元素。它们不会改变流中元素的顺序，也不会引入额外的状态。这些操作可以并行执行，适用于大规模数据集的处理。

filter：根据指定的条件过滤流中的元素，只保留满足条件的元素。
map(mapToInt, flatMap 等)：对流中的每个元素应用指定的函数，并将结果映射为一个新的流。
flatMap：对流中的每个元素应用指定的函数，并将结果扁平化为一个新的流。适用于将多个流合并成一个流的情况。
peek：对流中的每个元素执行指定的操作，不会改变流的内容，常用于调试和观察流中的元素。

1.2.有状态无序操作（Stateful & Unordered Operations）

需要维护一些额外的状态信息来执行操作。它们不会改变流中元素的顺序，但可能会引入一些性能开销。这些操作通常在处理较小的数据集或需要去重、排序等特定需求时使用。

sorted：对流中的元素进行排序，默认按照自然顺序进行排序，也可以传入自定义的Comparator进行排序。
distinct：去除流中的重复元素，根据元素的equals方法进行判断。

1.3.有状态有序操作（Stateful & Ordered Operations）

需要维护一些额外的状态信息来执行操作。它们可能会改变流中元素的顺序，因为它们涉及到元素的数量和位置。这些操作通常在处理有序数据集或需要分页、分段等特定需求时使用。

limit：限制流中元素的数量，只保留前n个元素。
skip：跳过流中的前n个元素，返回剩余的元素。

2.终止操作（Terminal Operations）

是对流进行最终的计算或收集操作，返回一个结果或一个最终的集合。

2.1.短路操作（Short-circuiting Operations）

操作在满足特定条件时可以提前结束流的遍历，不需要对所有元素进行处理。它们适用于大规模数据集的处理，可以提高性能和效率。

anyMatch：判断流中是否存在满足指定条件的元素，返回一个boolean类型的结果。一旦找到满足条件的元素，就会立即返回结果，不再继续遍历剩余元素。
allMatch：判断流中的所有元素是否都满足指定条件，返回一个boolean类型的结果。一旦找到不满足条件的元素，就会立即返回结果，不再继续遍历剩余元素。
noneMatch：判断流中是否没有任何元素满足指定条件，返回一个boolean类型的结果。一旦找到满足条件的元素，就会立即返回结果，不再继续遍历剩余元素。
findFirst：找到流中的第一个元素，返回一个Optional类型的结果。一旦找到第一个元素，就会立即返回结果，不再继续遍历剩余元素。
findAny：找到流中的任意一个元素，返回一个Optional类型的结果。一旦找到任意一个元素，就会立即返回结果，不再继续遍历剩余元素。

2.2.非短路操作（Non-short-circuiting Operations）

操作需要对所有元素进行处理，并返回一个最终的结果。它们适用于需要对所有元素进行汇总、统计或处理的场景。

forEach：对流中的每个元素执行指定的操作，遍历所有元素并执行操作，没有返回值。
collect：将流中的元素收集到一个集合或其他数据结构中，遍历所有元素并进行收集操作。返回收集的结果。
reduce：将流中的元素按照指定的规约操作进行合并，遍历所有元素并进行规约操作。返回一个最终结果。
min：找到流中的最小元素，根据元素的自然顺序或自定义的Comparator进行比较。
max：找到流中的最大元素，根据元素的自然顺序或自定义的Comparator进行比较。
count：计算流中的元素数量，遍历所有元素并进行计数操作。返回一个long类型的结果。

六、Stream并发问题

在使用Stream进行并发操作时，需要注意一些潜在的并发问题。虽然Stream API提供了内置的并行处理能力，但在处理共享可变状态或有副作用的操作时，可能会引发并发问题。

以下是一些常见的并发问题和建议的解决方案：

竞态条件（Race Conditions）：当多个线程同时访问和修改共享的可变状态时，可能导致不确定的结果。避免在并行流中进行共享可变状态的修改操作，或者使用线程安全的数据结构来保护共享状态。
线程安全性（Thread Safety）：某些操作可能不是线程安全的，例如非线程安全的集合类。在并行流中使用线程安全的数据结构或进行适当的同步操作，以确保线程安全性。
副作用（Side Effects）：在并行流中，应避免对外部状态产生副作用的操作，例如修改外部变量、I/O操作等。这可能导致不确定的结果或竞争条件。应尽量将操作限制在流的范围内，避免对外部状态的依赖。
顺序性（Ordering）：并行流的操作是并发执行的，因此不能保证操作的顺序。如果需要保持操作的顺序，可以使用forEachOrdered()方法代替forEach()方法。
性能问题（Performance Issues）：并行流的性能可能受到多核处理器的利用程度、任务划分的负载均衡等因素的影响。在使用并行流时，应根据具体情况进行性能测试和调优，以获得最佳的性能。

总之，在使用Stream进行并发操作时，需要注意并发问题，并采取适当的措施来确保线程安全性和正确性。避免共享可变状态、使用线程安全的数据结构、避免副作用操作，并进行性能测试和调优，可以提高并行流的效率和可靠性。

北纬@叶枫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
函数式编程（三）Stream流处理器

Stream是Java 8引入的一个用于处理集合数据的API。它提供了一种流式操作的方式，可以对集合进行过滤、映射、排序、聚合等各种操作，使得代码更加简洁、易读和易维护。Stream提供了一种流式操作的方式，可以对集合中的元素进行连续的操作，而不需要使用传统的循环和条件语句。Stream使用惰性求值的方式，只有在终止操作时才会执行实际的计算。这样可以避免不必要的计算，提高程序的性能。Stream使用内部迭代的方式，隐藏了迭代的细节，使得代码更加简洁和易读。Stream。
复制链接

扫一扫