读Java实战（第二版）笔记03_引入和使用流

1. 流

1.1. 以声明性方式处理数据集合

1.2. 通过查询语句来表达，而不是临时编写一个实现

1.3. 遍历数据集的高级迭代器

1.4. 透明地并行处理

1.5. 从支持数据处理操作的源生成的元素序列

1.5.1. 元素序列

1.5.1.1. 从有序集合生成流时会保留原有的顺序

1.5.2. 流的目的在于表达计算

1.5.3. 流会使用一个提供数据的源

1.5.3.1. 集合

1.5.3.2. 数组

1.5.3.3. I/O资源

1.5.4. 流的数据处理功能支持类似于数据库的操作

1.5.4.1. 顺序执行

1.5.4.2. 并行执行

1.6. 特点

1.6.1. 流水线

1.6.1.1. 延迟

1.6.1.2. 短路

1.6.2. 内部迭代

1.6.2.1. 流的迭代操作是在后台进行的

1.7. 只能遍历一次

1.8. 元素是按需计算的

1.9. 在概念上固定的数据结构

1.10. 在时间中分布的一组值

1.11. 延迟创建的

2. 集合

2.1. 急切创建的

2.2. 空间（这里就是计算机内存）中分布的一组值

2.3. 在一个时间点上全体存在

2.4. 一个内存中的数据结构

2.5. 包含数据结构中目前所有的值

2.6. 集合中的每个元素都得先算出来才能添加到集合中

3. 有序

3.1. 是按顺序取值，而不是随机取用

4. 外部迭代

4.1. for-each结构是一个语法糖

4.1.1. 背后用Iterator对象表达

4.2. 自己管理所有的并行问题

4.3. 

5. 内部迭代

5.1. Stream

5.2. 

6.  流操作

6.1. 中间操作

6.1.1. 可以连接起来的流操作

6.2. 终端操作

6.2.1. 关闭流的操作

6.2.2. 从流的流水线生成结果，其结果是任何不是流的值

7. 流的使用

7.1. 一个数据源（如集合）来执行一个查询

7.2. 一个中间操作链，形成一条流的流水线

7.3. 一个终端操作，执行流水线，并能生成结果

8. 高层次构件

8.1. filter

8.2. sorted

8.3. map

8.4. collect

9. Stream API

9.1. 声明性——更简洁，更易读

9.2. 可复合——更灵活

9.3. 可并行——性能更好

10. Optional类

10.1. java.util.Optional

10.2. 容器类

10.3. 代表一个值存在或不存在

10.4. isPresent()

10.4.1. 将在Optional包含值的时候返回true，否则返回false

10.5. ifPresent(Consumer block)

10.5.1. 会在值存在的时候执行给定的代码块

10.6. T get()

10.6.1. 在值存在时返回值，否则抛出一个NoSuchElement异常

10.7. T orElse(T other)

10.7.1. 在值存在时返回值，否则返回一个默认值

11. 使用流

11.1. 筛选

11.1.1. filter

11.1.1.1. 用谓词筛选，筛选出各不相同的元素

11.1.2. distinct

11.1.2.1. 返回一个元素各异（根据流所生成元素的hashCode和equals方法实现）的流

11.1.3. toSet()

11.2. 切片

11.2.1. Java 9

11.2.2. takeWhile

11.2.2.1. 在遭遇第一个不符合要求的元素时停止处理

11.2.3. dropWhile

11.2.3.1. 一旦遭遇谓词计算的结果为true，它就停止处理，并返回所有剩余的元素

11.2.3.2. 一个由无限数量元素构成的流，它也能工作得很好

11.3. 截短

11.3.1. limit(n)

11.3.1.1. 返回另一个不超过给定长度的流

11.3.1.2. 可以用在无序流上

11.3.1.2.1. 结果不会以任何顺序排列

11.3.1.3. 短路

11.3.1.3.1. 只需要创建一个给定大小的流，而用不着处理流中所有的元素

11.4. 跳过

11.4.1. skip(n)

11.5. 互补

11.6. 映射

11.6.1. map

11.6.1.1. 接受一个函数作为参数

11.6.1.2. 函数会被应用到每个元素上

11.6.1.3. 将其映射成一个新的元素

11.6.1.4. 是“创建一个新版本”而不是去“修改”

11.6.2. flatMap

11.6.2.1. 扁平化

11.6.2.2. 一个流中的每个值都换成另一个流，然后把所有的流连接起来成为一个流

11.7. 匹配

11.7.1. anyMatch

11.7.1.1. 流中是否有一个元素能匹配给定的谓词

11.7.2. allMatch

11.7.2.1. 流中的元素是否都能匹配给定的谓词

11.7.3. noneMatch

11.7.3.1. 流中没有任何元素与给定的谓词匹配

11.7.4. 短路

11.7.4.1. 可以把无限流变成有限流

11.7.4.2. 找到结果就立即停止计算；没有必要处理整个流

11.8. 查找

11.8.1. findAny

11.8.1.1. 返回当前流中的任意元素

11.8.1.2. 在使用并行流时限制较少

11.8.1.3. 不关心返回的元素是哪个时使用

11.8.2. findFirst

11.8.2.1. 出现顺序（encounter order）来指定流中项目出现的逻辑顺序

11.8.2.2. 找到第一个元素

11.8.2.3. 在并行上限制更多

11.9. 归约

11.9.1. 折叠（fold）

11.9.2. 将流归约成一个值

11.9.3. reduce

11.9.3.1. 有初始值版

11.9.3.1.1. 一个初始值

11.9.3.1.2. 一个BinaryOperator来将两个元素结合起来产生一个新值

11.9.3.2. 无初始值版

11.9.3.2.1. 不接受初始值

11.9.3.2.2. 会返回一个Optional对象

11.9.4. count

11.9.5. 求和

11.9.5.1. Integer::sum

11.9.6. 最大值

11.9.6.1. Integer::max

11.9.7. 最小值

11.9.7.1. Integer::min

11.10. map-reduce模式

11.10.1. map和reduce的连接

11.10.2. Google用它来进行网络搜索而出名

11.10.3. 很容易并行化

12. 状态界限

12.1. 无状态

12.1.1. 没有内部可变状态

12.1.2. map

12.1.3. filter

12.2. 有界

12.2.1. 内部状态很小

12.2.2. reduce

12.2.3. sum

12.2.4. max

12.3. 无界

12.3.1. 需要知道先前的历史

12.3.2. 存储要求是无界的

12.3.3. sort

12.3.4. distinct

12.3.5. 有状态

12.4. 

13. 并行执行的代价

13.1. 传递给reduce的Lambda不能更改状态

13.2. 操作必须满足结合律才可以按任意顺序执行

14. 原始类型流特化

14.1. 特化的原因

14.1.1. 装箱造成的复杂性

14.1.1.1. 即类似int和Integer之间的效率差异

14.1.2. 并不在于流的复杂性

14.2. IntStream、DoubleStream和LongStream

14.2.1. max

14.2.2. sum

14.2.3. min

14.2.4. average

14.3. mapToInt、mapToDouble和mapToLong

14.4. OptionalInt、OptionalDouble和OptionalLong

14.4.1. Optional原始类型特化版本

14.5. boxed

14.5.1. 转换回对象流

14.5.2. 在需要将数值范围装箱成为一般流

14.6. 数值范围

14.6.1. range

14.6.1.1. 不包含结束值的

14.6.2. rangeClosed

14.6.2.1. 包含结束值

15. 构建流

15.1. Stream接口通过实现AutoCloseable接口

15.1.1. 资源的管理都由try代码块全权负责

15.2. Stream.of

15.2.1. 通过显式值创建一个流

15.3. Stream.ofNullable

15.3.1. 由可空对象创建流

15.4. Arrays.stream

15.4.1. 从数组创建一个流

15.5. Files.lines

15.5.1. 由文件生成流

15.5.2. java.nio.file.Files

15.6. 无限流所包含的元素数量是无限的

15.6.1. 不能对无限流做排序或归约，因为所有元素都需要处理，而这永远也完不成

15.6.2. 由函数生成流

15.6.2.1. Stream.iterate

15.6.2.1.1. 使用limit(n)来对这种流加以限制

15.6.2.1.2. takeWhile解决这个问题，它能对流执行短路操作

15.6.2.1.3. 在需要依次生成一系列值的时候

15.6.2.1.4. Java 9对iterate方法进行了增强

15.6.2.1.4.1. 支持谓词操作

15.6.2.1.5. 纯粹不变的：它没有修改现有状态，但在每次迭代时会创建新的元组

15.6.2.2. Stream.generate

15.6.2.2.1. 不是依次对每个新生成的值应用函数的

15.6.2.2.2. 接受一个Supplier类型的Lambda提供新的值

15.6.2.2.3. 在并行代码中使用有状态的供应源是不安全的


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！