Java8实战-函数式数据处理-steam流之外部迭代与内部迭代

筑梦的熊

已于 2023-07-20 11:32:01 修改

阅读量206

点赞数 1

分类专栏： Java 文章标签： java jdk

于 2023-07-19 11:01:57 首次发布

本文链接：https://blog.csdn.net/weixin_42872138/article/details/131792967

版权

Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一.什么是流

流是Java API的新成员,它允许你以声明性方式处理数据集合.就现在来说,你可以把它们看成遍历数据集的高级迭代器.
此外，流还可以透明地并行处理，你无需写任何多线程代码.

譬如:下面两段代码都是用来返回低热量的菜肴名称的,并按照卡路里排序,一个是用Java 7写的,另一个是用Java 8的流写的.
Java7

public class Dish {

    private int calories;
    private String name;

    public static void main(String[] args) {

        List<Dish> menu = new ArrayList<>();//菜单
        List<Dish> lowCaloricDishes = new ArrayList<>();//低卡路菜肴集合
        //遍历菜单筛选出低卡路里菜肴
        for (Dish d : menu) {
            if (d.getCalories() < 400) {
                //用累加器筛选元素
                lowCaloricDishes.add(d);
            }
        }

        //用匿名类对菜肴排序
        Collections.sort(lowCaloricDishes, new Comparator<Dish>() {
            public int compare(Dish d1, Dish d2) {
                return Integer.compare(d1.getCalories(), d2.getCalories());
            }
        });
        //处理排序后的菜名列表
        List<String> lowCaloricDishesName = new ArrayList<>();
        for (Dish d : lowCaloricDishes) {
            lowCaloricDishesName.add(d.getName());
        }
    }
}

上述用了一个变量lowCaloricDishes,它唯一的作用就是作为一次性的中间容器.
Java8

import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.toList; 

public class Dish {

    private int calories;
    private String name;

    public static void main(String[] args) {
        List<Dish> menu = new ArrayList<>();//菜单
        List<String> lowCaloricDishesName = menu.stream()
                .filter(d -> d.getCalories() < 400)//遍历菜单筛选出低卡路里菜肴
                .sorted(comparing(Dish::getCalories))//按照卡路里排序
                .map(Dish::getName)//提取菜肴的名称
                .collect(toList());
    }
}

为了利用多核架构并行执行这段代码,你只需要把stream()换成parallelStream():

        List<String> lowCaloricDishesName = menu.parallelStream()
                .filter(d -> d.getCalories() < 400)
                .sorted(comparing(Dish::getCalories))
                .map(Dish::getName)
                .collect(toList());

如此做法好处有以下:
1.代码片段为声明性方式,代码具备声明性、复合性、并行性.
2.以把几个基础操作链接起来,表达复杂的数据处理流水线,同时保持代码清晰可读.

filter的结果被传给了sorted方法，再传给map方法，最后传给collect方法。
这样做法是因为filter、sorted、map和collect等操作是与具体线程模型无关的高层次构件，所以它们的内部实现可以是单线程的，也可能透明地充分利用你的多核架构！在实践中，这意味着你用不着为了让某些数据处理任务并行而去操心线程和锁了，Stream API都替你做好了.

二.流简介

Java 8中的集合支持一个新的stream方法,它会返回一个流（接口定义在java.util.stream.Stream里）.简单阐述流的含义是从支持数据处理操作的源生成的元素序列.
元素序列:像集合一样，流也提供了一个接口，可以访问特定元素类型的一组有序值。因为集合是数据结构，所以它的主要目的是以特定的时间/空间复杂度存储和访问元素（如ArrayList 与 LinkedList）。但流的目的在于表达计算，比如你前面见到的filter、sorted和map。集合讲的是数据，流讲的是计算。
源:流会使用一个提供数据的源，如集合、数组或输入/输出资源。请注意，从有序集合生成流时会保留原有的顺序。由列表生成的流，其元素顺序与列表一致。
数据处理操作:流的数据处理功能支持类似于数据库的操作，以及函数式编程语言中的常用操作，如filter、map、reduce、find、match、sort等。流操作可以顺序执行，也可并行执行。
此外，流操作有两个重要的特点。
流水线:很多流操作本身会返回一个流，这样多个操作就可以链接起来，形成一个大的流水线。流水线的操作可以看作对数据源进行数据库式查询。
内部迭代:与使用迭代器显式迭代的集合不同，流的迭代操作是在背后进行的。

例子代码片段

        List<Dish> menu = new ArrayList<>();//菜单
        List<String> threeHighCaloricDishNames = menu.stream()//从menu获得流b并建立操作流水线
                .filter(d -> d.getCalories() > 300)//首先选出高热量的菜肴
                .map(Dish::getName)//获取菜名
                .limit(3)//只选择前三条数据
                .collect(toList());//将结果保存在另一个List中
        System.out.println(threeHighCaloricDishNames);

解析:
1.我们先是对menu调用stream方法，由菜单得到一个流。
2.数据源是菜肴列表（菜单），它给流提供一个元素序列。
3.接下来，对流应用一系列数据处理操作：filter、map、limit和collect。除了collect之外，所有这些操作都会返回另一个流，这样它们就可以接成一条流水线，于是就可以看作对源的一个查询。
4.最后，collect操作开始处理流水线，并返回结果（它和别的操作不一样，因为它返回的不是流，在这里是一个List）。
在调用collect之前，没有任何结果产生，实际上根本就没有从menu里选择元素。也可以这么理解：链中的方法调用都在排队等待，直到调用collect。
.
流操作的顺序：filter、map、limit、collect，每个操作简介如下:

filter——接受Lambda，从流中排除某些元素。在本例中，通过传递lambda d -> d.getCalories() > 300，选择出热量超过300卡路里的菜肴。
map——接受一个Lambda，将元素转换成其他形式或提取信息。在本例中，通过传递方法引用Dish::getName，相当于Lambda d -> d.getName()，提取了每道菜的菜名。
limit——截断流，使其元素不超过给定数量。
collect——将流转换为其他形式。在本例中，流被转换为一个列表。可以把collect看作能够接受各种方案作为参数，并将流中的元素累积成为一个汇总结果的操作。这里的toList()就是将流转换为列表的方案。

三.流与集合

粗略地说，集合与流之间的差异就在于什么时候进行计算。
>集合是一个内存中的数据结构，它包含数据结构中目前所有的值——集合中的每个元素都得先算出来才能添加到集合中。
流则是在概念上固定的数据结构（你不能添加或删除元素），其元素则是按需计算的。这对编程有很大的好处。用户仅仅从流中提取需要的值，而这些值在用户看不见的地方——只会按需生成。这是一种生产者－消费者的关系。从另一个角度来说，流就像是一个延迟创建的集合：只有在消费者要求的时候才会计算值（用管理学的话说这就是需求驱动，甚至是实时制造)。

和迭代器类似，流只能遍历一次。遍历完之后，我们就说这个流已经被消费掉了。你可以从原始数据源那里再获得一个新的流来重新遍历一遍，就像迭代器一样。

例如，以下代码会抛出一个异常，说流已被消费掉了：

List<String> title = Arrays.asList("Java8", "In", "Action");
Stream<String> s = title.stream();
s.forEach(System.out::println);//打印标题中的每个单词
s.forEach(System.out::println);//java.lang.IllegalStateException:流已被操作或关闭

四.外部迭代与内部迭代

使用Collection接口需要用户去做迭代（比如用for-each），这称为外部迭代。相反，Streams库使用内部迭代——它帮你把迭代做了，还把得到的流值存在了某个地方，你只要给出一个函数说要干什么就可以了。

集合：用for-each循环外部迭代

List<String> names = new ArrayList<>();
for(Dish d: menu){//显式顺序迭代菜单列表
 	names.add(d.getName());//提取名称并将其添加到累加器
}

集合：用背后的迭代器做外部迭代

List<String> names = new ArrayList<>();
Iterator<String> iterator = menu.iterator();
while(iterator.hasNext()) {
 	Dish d = iterator.next();
 	names.add(d.getName());
}

流：内部迭代

List<String> names = menu.stream().map(Dish::getName).collect(toList());

外部迭代一个集合，显式地取出每个项目再加以处理。内部迭代时，项目可以透明地并行处理，或者用更优化的顺序进行处理。
Streams库的内部迭代可以自动选择一种适合你硬件的数据表示和并行实现。与此相反，一旦通过写for-each而选择了外部迭代，那你基本上就要自己管理所有的并行问题了或开始了关于任务和synchronized的漫长而艰苦的斗争。Java 8需要一个类似于Collection却没有迭代器的接口，于是就有了Stream。
.
for-each还隐藏了迭代中的一些复杂性。for-each结构背后是用Iterator对象,源码如下:

四.流操作

中间操作和终端操作

java.util.stream.Stream中的Stream接口定义了许多操作。它们可以分为两大类。
我们再来看一下前面的例子：

可以连接起来的流操作称为中间操作，关闭流的操作称为终端操作。

诸如filter或sorted等中间操作会返回另一个流。这让多个操作可以连接起来形成一个查询。重要的是，除非流水线上触发一个终端操作，否则中间操作不会执行任何处理。这是因为中间操作一般都可以合并起来，在终端操作时一次性全部处理。
终端操作会从流的流水线生成结果。其结果是任何不是流的值，比如List、Integer，甚至void。

long count = menu.stream()
 .filter(d -> d.getCalories() > 300)
 .distinct()
 .limit(3)
 .count();

解析:
流水线中最后一个操作count返回一个long，这是一个非Stream的值。一个终端操作。所有前面的操作，filter、distinct、limit，都是连接起来的，并返回一个Stream，因此它们是中间操作。

流的延迟性质

        List<Dish> menu = new ArrayList<>();//菜单
        menu.add(new Dish(500,"麻婆豆腐"));
        menu.add(new Dish(400,"爆炒猪肝"));
        List<String> names =
                menu.stream()
                        .filter(d -> {
                            System.out.println("filtering:" + d.getName());
                            return d.getCalories() > 300;
                        })
                        .map(d -> {
                            System.out.println("mapping:" + d.getName());
                            return d.getName();
                        })
                        .limit(1)
                        .collect(toList());
        System.out.println(names);

结果:

filtering:麻婆豆腐
mapping:麻婆豆腐
[麻婆豆腐]

        List<String> names =
                menu.stream()
                        .filter(d -> {
                            System.out.println("filtering:" + d.getName());
                            return d.getCalories() > 300;
                        })
                        .map(d -> {
                            System.out.println("mapping:" + d.getName());
                            return d.getName();
                        })
                        .limit(3)//更改limit取值
                        .collect(toList());

filtering:麻婆豆腐
mapping:麻婆豆腐
filtering:爆炒猪肝
mapping:爆炒猪肝
[麻婆豆腐, 爆炒猪肝]

会发现优化利用了流的延迟性质，这是因为limit操作和一种称为短路的技巧，尽管filter和map是两个独立的操作，但它们合并到同一次遍历中了（我们把这种技术叫作循环合并）。

五.总结

流是“从支持数据处理操作的源生成的一系列元素”。
流利用内部迭代：迭代通过filter、map、sorted等操作被抽象掉了。
流操作有两类：中间操作和终端操作。
filter和map等中间操作会返回一个流，并可以链接在一起。可以用它们来设置一条流水线，但并不会生成任何结果。
forEach和count等终端操作会返回一个非流的值，并处理流水线以返回结果。
流中的元素是按需计算的。

原神,启动!
在这里插入图片描述

筑梦的熊

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java8实战-函数式数据处理-steam流之外部迭代与内部迭代

Java 8中的集合支持一个新的stream方法,它会返回一个流（接口定义在java.util.stream.Stream里）.简单阐述流的含义是从支持数据处理操作的源生成的元素序列.元素序列:像集合一样，流也提供了一个接口，可以访问特定元素类型的一组有序值。因为集合是数据结构，所以它的主要目的是以特定的时间/空间复杂度存储和访问元素（如ArrayList 与 LinkedList）。但流的目的在于表达计算，比如你前面见到的filter、sorted和map。集合讲的是数据，流讲的是计算。
复制链接

扫一扫