当前位置： 首页 > article >正文

《Java8实战》第4章 引入流

article 2024/11/14 12:45:51

集合是 Java 中使用最多的 API。

4.1 流是什么

流是 Java API 的新成员，它允许你以声明性方式处理数据集合（通过查询语句来表达，而不是临时编写一个实现）。可以看作是遍历数据集的高级迭代器，而且还可以并行的处理。
例子：返回低热量菜肴名称
Java7的实现

// 用累加器筛选元素
List<Dish> lowCaloricDishes = new ArrayList<>(); 
for(Dish dish: menu) { 
 if(dish.getCalories() < 400) { 
   lowCaloricDishes.add(dish); 
 } 
} 
// 用匿名类对菜肴排序
Collections.sort(lowCaloricDishes, new Comparator<Dish>() { 
 public int compare(Dish dish1, Dish dish2) { 
   return Integer.compare(dish1.getCalories(), dish2.getCalories()); 
 } 
}); 
// 处理排序后的菜名列表
List<String> lowCaloricDishesName = new ArrayList<>(); 
for(Dish dish: lowCaloricDishes) { 
 lowCaloricDishesName.add(dish.getName()); 
}

上面的代码还有一个“垃圾变量”lowCaloricDishes。
Java8的实现

import static java.util.Comparator.comparing; 
import static java.util.stream.Collectors.toList; 
List<String> lowCaloricDishesName = 
       menu.stream()
       .filter(d -> d.getCalories() < 400) // 选出 400 卡路里以下的菜肴
       .sorted(comparing(Dish::getCalories)) // 按照卡路里排序
       .map(Dish::getName) // 提取菜肴的名称
       .collect(toList()); // 将所有名称保存在 List 中

为了利用多核架构并行执行这段代码，你只需要把 stream()换成 parallelStream()
代码清晰可读。filter 的结果被传给了 sorted 方法，再传给 map 方法，最后传给 collect 方法。流水线一样
image.png

List<Dish> menu = Arrays.asList( 
 new Dish("pork", false, 800, Dish.Type.MEAT), 
 new Dish("beef", false, 700, Dish.Type.MEAT), 
 new Dish("chicken", false, 400, Dish.Type.MEAT), 
 new Dish("french fries", true, 530, Dish.Type.OTHER), 
 new Dish("rice", true, 350, Dish.Type.OTHER), 
 new Dish("season fruit", true, 120, Dish.Type.OTHER), 
 new Dish("pizza", true, 550, Dish.Type.OTHER), 
 new Dish("prawns", false, 300, Dish.Type.FISH), 
 new Dish("salmon", false, 450, Dish.Type.FISH) ); 
Dish 类的定义是：
public class Dish { 
 private final String name; 
 private final boolean vegetarian; 
 private final int calories; 
 private final Type type; 
 public Dish(String name, boolean vegetarian, int calories, Type type) { 
   this.name = name; 
   this.vegetarian = vegetarian; 
   this.calories = calories; 
   this.type = type; 
 } 
 public String getName() { 
   return name; 
 } 
 public boolean isVegetarian() { 
   return vegetarian; 
 } 
 public int getCalories() { 
   return calories; 
 } 
 public Type getType() { 
   return type; 
 } 
 @Override 
 public String toString() { 
   return name; 
 } 
 public enum Type { MEAT, FISH, OTHER } 
}

接下来会谈到很多模式，比如筛选、切片、查找、匹配、映射和归约。

4.2 流简介

流简短的定义就是“从支持数据处理操作的源生成的元素序列”

  • 元素序列——就像集合一样，流也提供了一个接口，可以访问特定元素类型的一组有序值。集合讲的是数据，流讲的是计算。
  • 源——流会使用一个提供数据的源，比如集合、数组或 I/O 资源。由列表生成的流，其元素顺序与列表一致。
  • 数据处理操作——流的数据处理功能支持类似于数据库的操作，以及函数式编程语言中的常用操作，比如 filter、map、reduce、find、match、sort 等。流操作可以顺序执行，也可以并行执行。
  • 流水线——很多流操作本身会返回一个流，这样多个操作就可以链接起来，构成一个更大的流水线。
  • 内部迭代——与集合使用迭代器进行显式迭代不同，流的迭代操作是在后台进行的。
import static java.util.stream.Collectors.toList; 
List<String> threeHighCaloricDishNames = 
 menu.stream() // 从 menu（菜肴列表）获得流
   .filter(dish -> dish.getCalories() > 300) // 建立操作流水线：首先选出高热量的菜肴
   .map(Dish::getName) // 获取菜名
   .limit(3) // 只选择头三个
   .collect(toList()); // 将结果保存在另一个 List 中
System.out.println(threeHighCaloricDishNames); // 结果是[pork, beef, chicken]

本例先是对 menu 调用 stream 方法，由菜单得到一个流。数据源是菜肴列表（菜单），它给流提供一个元素序列。接下来，对流应用一系列数据处理操作：filter、map、limit 和collect。除了 collect 之外，所有这些操作都会返回另一个流，这样它们就可以接成一条流水线，于是就可以看作对源的一个查询。
最后，collect 操作开始处理流水线，并返回结果（它和别的操作不一样，因为它返回的不是流，在这里是一个 List）。在调用 collect 之前，没有任何结果产生，实际上根本就没有从 menu 里选择元素。你可以这么理解：链中的方法调用都在排队等待，直到调用 collect。
filter——接受一个 Lambda，从流中排除某些元素。在本例中，通过传递 Lambda d -> d.getCalories() > 300，选择出热量超过 300 卡路里的菜肴。
map——接受一个 Lambda，将元素转换成其他形式或提取信息。在本例中，通过传递方法引用 Dish::getName，相当于 Lambda d -> d.getName()，提取了每道菜的菜名。
limit——截断流，使其元素不超过给定数量。
collect——将流转换为其他形式。在本例中，流被转换为一个列表。它看起来有点儿像变魔术，第 6 章会详细解释 collect 的工作原理。现在，你可以把 collect 看作能够接受各种方案作为参数，并将流中的元素累积成为一个汇总结果的操作。这里的toList()就是将流转换为列表的方案。
image.png

4.3 流与集合

流就像是一个延迟创建的集合：只有在消费者要求的时候才会计算值
用 DVD 对比在线流媒体的例子展示了流和集合之间的差异。
image.png

4.3.1 只能遍历一次

和迭代器类似，流只能遍历一次。遍历完之后，这个流就已经被消费掉了。
流只能消费一次，多次就会抛异常

List<String> title = Arrays.asList("Modern", "Java", "In", "Action"); 
Stream<String> s = title.stream(); 
s.forEach(System.out::println); 
s.forEach(System.out::println); // 抛异常 java.lang.IllegalStateException:流已被操作或关闭

4.3.2 外部迭代与内部迭代

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

List<String> names = new ArrayList<>(); 
for(Dish dish: menu){ // 显式顺序迭代菜单列表
 names.add(dish.getName()); 
}

for-each 还隐藏了迭代中的一些复杂性。for-each 结构是一个语法糖，它背后的东西用 Iterator 对象表达出来会更丑陋。
集合：用背后的迭代器做外部迭代

List<String> names = new ArrayList<>(); 
Iterator<String> iterator = menu.iterator(); 
while(iterator.hasNext()) { // 显示迭代
 Dish dish = iterator.next(); 
 names.add(dish.getName()); 
}

流：内部迭代

List<String> names = menu.stream() 
   .map(Dish::getName) // 用 getName 方法参数化 map，提取菜名
   .collect(toList()); // 开始执行操作流水线；没有迭代！

比如地上有一堆散落的玩具。需要叫孩子收拾
外部迭代一个集合，显式地取出每个项目再加以处理。我们只需要对孩子说，“把地上所有的玩具都放进盒子里”就好了。
内部迭代比较好的原因有两个：第一，孩子可以选择一只手拿娃娃，另一只手拿球；第二，她可以决定先拿离盒子最近的那个东西，然后再拿别的。
内部迭代时，项目可以透明地并行处理，或者以更优化的顺序进行处理，还可以轻松的并行执行，不需我们管理。
image.png

测验 4.1：外部迭代与内部迭代
基于你对代码清单 4-1 和代码清单 4-2 中外部迭代的学习，请选择一种流操作来重构下面的代码。
List highCaloricDishes = new ArrayList<>();
Iterator iterator = menu.iterator();
while(iterator.hasNext()) {
Dish dish = iterator.next();
if(dish.getCalories() > 300) {
highCaloricDishes.add(d.getName());
}
}
答案：应该选择使用 filter 模式。
List highCaloricDish = menu.stream() .filter(dish -> dish.getCalories() > 300) .collect(toList());

4.4 流操作

filter、map、limit这些都是中间操作，可以连成一条流水线；
collect 触发流水线执行并关闭它。
可以连接起来的流操作称为中间操作，关闭流的操作称为终端操作。
image.png

4.4.1 中间操作

除非流水线上触发一个终端操作，否则中间操作不会执行任何处理。这是因为中间操作一般都可以合并起来，在终端操作时一次性全部处理。
打印流的处理过程

List<String> names = 
 menu.stream() 
 .filter(dish -> { 
 System.out.println("filtering:" + dish.getName()); // 打印当前筛选的菜肴
 return dish.getCalories() > 300; 
 }) 
 .map(dish -> { 
 System.out.println("mapping:" + dish.getName()); // 提取菜名时打印出来
 return dish.getName(); 
 })
 .limit(3) 
 .collect(toList()); 
System.out.println(names); 

输出：
filtering:pork 
mapping:pork 
filtering:beef 
mapping:beef 
filtering:chicken 
mapping:chicken 
[pork, beef, chicken]

尽管很多菜的热量都高于 300 卡路里，但只选出了前三个！这是因为 limit 操作和一种称为短路的技巧，
尽管 filter 和 map 是两个独立的操作，但它们合并到同一次遍历中了（我们把这种技术叫作循环合并）

4.4.2 终端操作

终端操作会从流的流水线生成结果，其结果是任何不是流的值，比如 List、Integer，甚至 void。

测验 4.2：中间操作与终端操作
在下列流水线中，你能找出中间操作和终端操作吗？
long count = menu.stream()
.filter(dish -> dish.getCalories() > 300)
.distinct()
.limit(3)
.count();
答案：流水线中最后一个操作 count 返回一个 long，这是一个非 Stream 的值。因此它是一个终端操作。所有前面的操作，filter、distinct、limit，都是连接起来的，并返回一个 Stream，因此它们是中间操作。

4.4.3 使用流

流的使用一般包括三件事：

  • 一个数据源（如集合）来执行一个查询；
  • 一个中间操作链，形成一条流的流水线；
  • 一个终端操作，执行流水线，并能生成结果。

image.png

4.5 路线图

4.6 小结

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

http://www.kler.cn/a/9772.html

相关文章：

  • 深入解析 OpenHarmony 构建系统-4-OHOSLoader类
  • 24.11.13 Javascript3
  • Openstack7--安装消息队列服务RabbitMQ
  • 物理设备命名规则（Linux网络服务器 15）
  • Java 网络编程（一）—— UDP数据报套接字编程
  • 使用@react-three/fiber,@mkkellogg/gaussian-splats-3d加载.splat，.ply，.ksplat文件
  • 【voliate 关键字】
  • 行为型模式-命令模式
  • BAT程序员来说一说互联网大厂的秋招和实习，什么时候开始秋招，要不要准备实习？ 没找到实习怎么办？实习是不是重要？ 如何选择实习的offer？
  • MySQL开发04-MySQL优化器的提示功能
  • 小黑子—Java从入门到入土过程：第六章
  • 【openAI】调用gpt-xxx模型时显示网络连接错误（Error communicating with openAI...）
  • 封仲淹：OceanBase开源技术生态全景解析
  • Java基础教程之Object类是怎么回事？
  • 采用多种方式实现项目的查询多级缓存(四)
  • Java模拟rank() over()函数获取分组排名的方法设计及实现
  • 书 | 图理论 | 2020年GraphSage提出者William L. Hamilton《图表示学习》
  • Systemverilog中Constrained random value generation的记录
  • linux之pthread_join函数
  • 安全防御 --- APT、密码学
  • 《数据库系统概论》第三章课后习题 (4个表+三建工程项目)
  • JAVA所有版本特性【JAVA 1.0 - JAVA 20】
  • 圣戈班Saint-Gobain EDI需求分析
  • 计算机网络 - TCP的效率与特性
  • 从0到1基于ChatGLM-6B使用LaRA进行参数高效微调 审核中
  • 49.现有移动端开源框架及其特点—MACE（ Mobile AI Compute Engine）