《Java8实战》学习笔记

第一部分 基础知识

1.为什么要关心Java8

2.通过行为参数化传递代码

3.Lambda 表达式

第二部分 函数式数据处理

4.引入流

5.使用流

6.用流收集数据

7.并行数据处理与性能

第三部分 高效Java 8编程

8.重构、测试和调试

9.默认方法

10.用Optional取代null

11.CompletableFuture：组合式异步编程

12.新的日期和时间API

第四部分 超越Java 8

13.函数式的思考

14.函数式编程的技巧

15.面向对象和函数式编程的混合：Java 8和Scala的比较

16.结论以及Java的未来

---

第一部分 基础知识

1

1.为什么要关心Java8

1.1.Java 怎么还在变

1.1.1.Java 在编程语言生态系统中的位置

1.1.2.流处理

1.1.3.用行为参数化把代码传递给方法

1.1.4.并行与共享的可变数据

1.1.5.Java 需要演变

1.2.Java 中的函数

1.2.1.方法和Lambda 作为一等公民

1.2.2.传递代码：一个例子

1.2.3.从传递方法到Lambda

1.3.流

1.3.1.多线程并非易事

1.4.默认方法

1.5.来自函数式编程的其他好思想

2

2.通过行为参数化传递代码

2.1.应对不断变化的需求

2.1.1.初试牛刀：筛选绿苹果

2.1.2.再展身手：把颜色作为参数

2.1.3.第三次尝试：对你能想到的每个属性做筛选

2.2.行为参数化

2.2.1.第四次尝试：根据抽象条件筛选

2.2.1.1.传递代码/行为

2.2.1.2.多种行为，一个参数

2.3.对付啰嗦

2.3.1.匿名类

2.3.2.第五次尝试：使用匿名类

2.3.3.第六次尝试：使用Lambda 表达式

2.3.4.第七次尝试：将List 类型抽象化

2.4.真实的例子

2.4.1.用Comparator来排序

2.4.2.用Runnable执行代码块

2.4.3.GUI 事件处理

2.5.小结

3

3.Lambda 表达式

3.1.Lambda 管中窥豹

3.2.在哪里以及如何使用Lambda

3.2.1.函数式接口

3.2.2.函数描述符

3.3.把Lambda 付诸实践：环绕执行模式

3.3.1.第1步：记得行为参数化

3.3.2.第2步：使用函数式接口来传递行为

3.3.3.第3步：执行一个行为

3.3.4.第4步：传递Lambda

3.4.使用函数式接口

3.4.1.Predicate

3.4.2.Consumer

3.4.3.Function

3.4.4.原始类型特化

3.4.5.异常

3.5.类型检查、类型推断以及限制

3.5.1.类型检查

3.5.2.同样的Lambda，不同的函数式接口

3.5.3.类型推断

3.5.4.使用局部变量

3.6.方法引用

3.6.1.管中窥豹

3.6.1.1.如何构建方法引用

3.6.2.构造函数引用

3.7.Lambda和方法引用实战

3.7.1.第1步：传递代码

3.7.2.第2步：使用匿名类

3.7.3.第3步：使用Lambda表达式

3.7.4.第4步：使用方法引用

3.8.复合Lambda表达式的有用的方法

3.8.1.比较器复合

3.8.1.1.逆序

3.8.1.2.比较器链

3.8.2.谓词复合

3.8.3.函数复合

3.8.4.数学中类似的思想

3.9.小结

第二部分 函数式数据处理

4

4.引入流

4.1.流是什么

4.2.流简介

4.3.流与集合

4.3.1.只能遍历一次

4.3.2.外部迭代与内部迭代

4.4.流操作

4.4.1.中间操作

4.4.2.终端操作

4.4.3.使用流

4.5.小结

5

5.使用流

5.1.筛选和切片

5.1.1.用谓词Predicate筛选-filter

5.1.2.筛选各异的元素-去重-distinct

5.1.3.截短流-limit

5.1.4.跳过元素-skip

5.2.映射-map

5.2.1.对流中每一个元素应用函数-map

5.2.2.流的扁平化-flatMap

5.2.2.1.更多流的扁平化例子

5.3.查找和匹配-find-match

5.3.1.检查谓词是否至少匹配一个元素-anyMatch

5.3.2.检查谓词是否匹配所有元素-allMatch

5.3.3.检查谓词是否不匹配所有元素-noneMatch

5.3.4.查找元素-findAny

5.3.4.1.Optional一览

5.3.5.查找第一个元素-findFirst

5.3.6.何时使用findFirst和findAny

5.4.归约-reduce

5.4.1.元素求和

5.4.2.元素求积

5.4.3.最大值和最小值

5.4.4.总数

5.4.5.归约方法的优势与并行化

5.4.6.流操作：无状态和有状态

5.4.7.中间操作和终端操作小结

5.5.付诸实践

5.5.1.领域：交易员和交易

5.5.2.解答

5.6.数值流

5.6.1.原始类型流特化

5.6.1.1.映射到数值流-mapToXXX

5.6.1.2.转换回对象流-boxed

5.6.1.3.默认值-OptionalInt

5.6.2.数值范围-range

5.6.3.数值流应用:勾股数

5.6.3.1.勾股数

5.6.3.2.表示三元数

5.6.3.3.筛选成立的组合

5.6.3.4.生成三元组

5.6.3.5.生成b值

5.6.3.6.生成值

5.6.3.7.运行代码

5.6.3.8.更上一层楼

5.7.构建流

5.7.1.由值创建流

5.7.2.由数组创建流

5.7.3.由文件生成流

5.7.4.由函数生成流：创建无限流

5.7.4.1.迭代-iterate

5.7.4.2.迭代-斐波纳契数列

5.7.4.3.生成

5.7.4.4.生成-斐波纳契数列

5.8.小结

6

6.用流收集数据

6.1.收集器简介

6.1.1.收集器用作高级归约

6.1.2.预定义收集器

6.2.归约和汇总

6.2.1.查找流中的最大值和最小值

6.2.2.汇总

6.2.3.连接字符串

6.2.4.广义的归约汇总

6.2.4.1.Stream接口的collect和reduce有何不同

6.2.4.2.收集框架的灵活性：以不同的方法执行同样的操作

6.2.4.3.根据情况选择最佳解决方案

6.2.4.4.用reducing连接字符串

6.3.分组

6.3.1.多级分组

6.3.2.按子组收集数组

6.3.2.1.把收集器的结果转换为另一种类型

6.3.2.2.与groupingBy联合使用的其他收集器的例子

6.4.分区

6.4.1.分区的优势

6.4.2.将数字按质数和非质数分区

6.4.3.Collectors类的静态工厂方法

6.5.收集器接口

6.5.1.理解Collector 接口声明的方法

6.5.1.1.建立新的结果容器：supplier方法

6.5.1.2.将元素添加到结果容器：accumulator方法

6.5.1.3.对结果容器应用最终转换：finisher方法

6.5.1.4.合并两个结果容器：combiner方法

6.5.1.5.characteristics方法

6.5.2.全部融合到一起

6.5.2.1.进行自定义收集而不去实现Collector

6.6.开发你自己的收集器以获得更好的性能

6.6.1.仅用质数做除数

6.6.1.1.第一步：定义Collector类的签名

6.6.1.2.第二步：实现归约过程

6.6.1.3.第三步：让收集器并行工作（如果可能）

6.6.1.4.第四步：finisher方法和收集器的characteristics方法

6.6.2.比较收集器的性能

6.7.小结

7

7.并行数据处理与性能

7.1.并行流

7.1.1.将顺序流转换为并行流

7.1.2.测量流性能

7.1.2.1.使用更有针对性的方法

7.1.3.正确使用并行流

7.1.4.高效使用并行流建议

7.2.分支/合并框架

7.2.1.使用RecursiveTask

7.2.1.1.运行ForkJoinSumCalculator

7.2.2.使用分支/合并框架的最佳做法

7.2.3.工作窃取

7.3.Spliterator

7.3.1.拆分过程

7.3.1.1.Spliterator的特性

7.3.2.实现你自己的Spliterator

7.3.2.1.以函数式风格重写单词计数器

7.3.2.2.让WordCounter并行工作

7.4.小结

第三部分 高效Java 8编程

8

8.重构、测试和调试

8.1.为改善可读性和灵活性重构代码

8.1.1.改善代码的可读性

8.1.2.从匿名类到Lambda表达式的转换

8.1.3.从Lambda表达式到方法引用的转换

8.1.4.从命令式的数据处理切换到Stream

8.1.5.增加代码的灵活性

8.1.5.1.采用函数接口

8.1.5.2.有条件的延迟执行

8.1.5.3.环绕执行

8.2.使用Lambda重构面向对象的设计模式

8.2.1.策略模式

8.2.1.1.使用Lambda表达式

8.2.2.模板方法

8.2.2.1.使用Lambda表达式2

8.2.3.观察者模式

8.2.3.1.使用Lambda表达式3

8.2.4.责任链模式

8.2.4.1.使用Lambda表达式4

8.2.5.工厂模式

8.2.5.1.使用Lambda表达式5

8.3.测试Lambda表达式

8.3.1.测试可见Lambda 函数的行为

8.3.2.测试使用Lambda 的方法的行为

8.3.3.将复杂的Lambda 表达式分到不同的方法

8.4.调试

8.4.1.查看栈跟踪

8.4.2.使用日志调试

8.5.小结

9

9.默认方法

9.1.不断演进的API

9.1.1.初始版本的API

9.1.2.用户实现

9.1.3.第二版API

9.1.4.用户面临的窘境

9.1.5.不同类型的兼容性：二进制、源代码和函数行为

9.2.概述默认方法

9.2.1.Java 8中的抽象类和抽象接口

9.2.2.使用默认实现的例子——removeIf

9.3.默认方法的使用模式

9.3.1.可选方法

9.3.2.行为的多继承

9.3.2.1.类型的多继承

9.3.2.2.利用正交方法的精简接口

9.3.2.3.组合接口

9.3.2.4.继承不应该成为你一谈到代码复用就试图倚靠的万金油

9.4.解决冲突的规则

9.4.1.解决问题的三条规则

9.4.2.选择提供了最具体实现的默认方法的接口

9.4.3.冲突及如何显式地消除歧义

9.4.4.菱形继承问题

9.5.小结

10

10.用Optional取代null

10.1.如何为缺失的值建模

10.1.1.采用防御式检查减少NullPointerException

10.1.1.1.深层质疑

10.1.1.2.过多的退出语句

10.1.2.null带来的种种问题

10.1.3.其他语言中null的替代品

10.2.Optional类入门

10.3.应用Optional的几种模式

10.3.1.创建Optional对象

10.3.1.1.声明一个空的Optional

10.3.1.2.依据一个非空值创建Optional

10.3.1.3.可接受null的Optional

10.3.2.使用map从Optional对象中提取和转换值

10.3.3.使用flatMap链接Optional对象

10.3.3.1.使用Optional获取car的保险公司名称

10.3.3.2.使用Optional解引用串接的Person/Car/Insurance对象

10.3.3.3.在域模型中使用Optional，以及为什么它们无法序列化

10.3.4.默认行为及解引用Optional对象

10.3.5.两个Optional对象的组合

10.3.6.以不解包的方式组合两个Optional对象

10.3.7.使用filter剔除特定的值

10.3.8.对Optional对象进行过滤

10.3.9.Optional类的方法

10.4.使用Optional的实战示例

10.4.1.用Optional封装可能为null的值

10.4.2.异常与Optional的对比

10.4.3.基础类型的Optional对象，以及为什么应该避免使用它们

10.4.4.把之前所有内容整合起来

10.5.小结

11

11.CompletableFuture：组合式异步编程

11.1.Future接口

11.1.1.Future接口的局限性

11.1.2.使用CompletableFuture构建异步应用

11.1.3.同步API与异步API

11.2.实现异步API

11.2.1.将同步方法转换为异步方法

11.2.2.错误处理

11.2.2.1.使用工厂方法supplyAsync创建CompletableFuture

11.3.让你的代码免受阻塞之苦——将无法改变的同步适配成异步

11.3.1.使用并行流对请求进行并行操作

11.3.2.使用CompletableFuture发起异步请求

11.3.3.寻找更好的方案

11.3.4.使用定制的执行器

11.3.4.1.调整线程池的大小

11.3.4.2.并行——使用Stream还是CompletableFutures？

11.4.对多个异步任务进行流水线操作

11.4.1.实现折扣服务

11.4.2.使用Discount服务

11.4.3.构造同步和异步操作

11.4.4.将两个CompletableFuture对象整合起来，无论它们是否存在依赖

11.4.5.对Future和CompletableFuture的回顾

11.5.即时响应——CompletableFuture的completion事件

11.5.1.对最佳价格查询器应用的优化

11.5.2.付诸实践

11.6.小结

12

12.新的日期和时间API

12.1.LocalDate、LocalTime、Instant、Duration 以及Period

12.1.1.使用LocalDate 和LocalTime

12.1.2.合并日期和时间

12.1.3.机器的日期和时间格式

12.1.4.定义Duration或Period

12.2.操纵、解析和格式化日期

12.2.1.使用TemporalAdjuster

12.2.1.1.自定义TemporalAdjuster

12.2.2.打印输出及解析日期-时间对象

12.3.处理不同的时区和历法

12.3.1.利用和UTC/格林尼治时间的固定偏差计算时区

12.3.2.使用别的日历系统

12.4.小结

第四部分 超越Java 8

13

13.函数式的思考

13.1.实现和维护系统

13.1.1.共享的可变数据

13.1.2.声明式编程

13.1.2.1.专注于如何实现

13.1.2.2.关注要做什么

13.1.3.为什么要采用函数式编程

13.2.什么是函数式编程

13.2.1.函数式Java编程

13.2.2.引用透明性

13.2.3.面向对象的编程和函数式编程的对比

13.2.4.函数式编程实战

13.3.递归和迭代

13.4.小结

14

14.函数式编程的技巧

14.1.无处不在的函数

14.1.1.高阶函数

14.1.2.副作用和高阶函数

14.1.3.科里化

14.1.4.科里化的理论定义

14.2.持久化数据结构

14.2.1.破坏式更新和函数式更新的比较

14.2.2.另一个使用Tree的例子

14.2.3.采用函数式的方法

14.3.Stream的延迟计算

14.3.1.自定义Stream

14.3.1.1.第一步：构造由数字组成的Stream

14.3.1.2.第二步：取得首元素

14.3.1.3.第三步：对尾部元素进行筛选

14.3.1.4.第四步：递归地创建由质数组成的Stream

14.3.1.5.坏消息

14.3.1.6.延迟计算

14.3.2.创建你自己的延迟列表

14.3.2.1.一个基本的链接列表

14.3.2.2.一个基础的延迟列表

14.3.2.3.回到生成质数

14.3.2.4.实现一个延迟筛选器

14.3.2.5.何时使用

14.4.模式匹配

14.4.1.访问者设计模式

14.4.2.用模式匹配力挽狂澜

14.4.2.1.Java中的伪模式匹配

14.5.杂项

14.5.1.缓存或记忆表

14.5.2.“返回同样的对象”意味着什么

14.5.3.结合器

14.6.小结

15

15.面向对象和函数式编程的混合：Java 8和Scala的比较

15.1.Scala简介

15.1.1.HelloWorld

15.1.1.1.命令式Scala

15.1.1.2.函数式Scala

15.1.2.基础数据结构：List、Set、Map、Tuple、Stream以及Option

15.1.2.1.创建集合

15.1.2.2.不可变与可变的比较

15.1.2.3.使用集合

15.1.2.4.元组

15.1.2.5.Stream

15.1.2.6.Option

15.2.函数

15.2.1.Scala中的一等函数

15.2.2.匿名函数和闭包

15.2.3.科里化

15.3.类和trait

15.3.1.更加简洁的Scala类

15.3.2.Scala的trait与Java8的接口对比

15.4.小结

16

16.结论以及Java的未来

16.1.回顾Java8的语言特性

16.1.1.行为参数化（Lambda以及方法引用）

16.1.2.流

16.1.3.CompletableFuture

16.1.4.Optional

16.1.5.默认方法

16.2.Java的未来

16.2.1.集合

16.2.2.类型系统的改进

16.2.2.1.声明位置变量

16.2.2.2.更多的类型推断

16.2.3.模式匹配

16.2.4.更加丰富的泛型形式

16.2.4.1.具化泛型

16.2.4.2.泛型中特别为函数类型增加的语法灵活性

16.2.4.3.原型特化和泛型

16.2.5.对不变性的更深层支持

16.2.6.值类型

16.2.6.1.为什么编译器不能对Integer和int一视同仁

16.2.6.2.值对象——无论简单类型还是对象类型都不能包打天下

16.2.6.3.装箱、泛型、值类型——互相交织的问题

16.3.写在最后的话

附录

来源：oschina

链接：https://my.oschina.net/jallenkwong/blog/3164835