[201911][Java 实战][第2版][陆明刚][劳佳][译]

第一部分 基础知识

第 1 章 Java 8、9、10 以及 11 的变化

1.1 为什么要关心 Java 的变化

1.2 Java 怎么还在变

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

1.2.2 流处理

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

1.2.4 并行与共享的可变数据

1.2.5 Java 需要演变

1.3 Java 中的函数

1.3.1 方法和 Lambda 作为一等值

1.3.2 传递代码：一个例子

1.3.3 从传递方法到 Lambda

1.4 流

1.5 默认方法及 Java 模块

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

1.7 小结

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

2.1 应对不断变化的需求

2.1.1 初试牛刀：筛选绿苹果

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

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

2.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 通过 Callable 返回结果

2.4.4 GUI 事件处理

2.5 小结

第 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.5 类型检查、类型推断以及限制

3.5.1 类型检查

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

3.5.3 类型推断

3.5.4 使用局部变量

3.6 方法引用

3.6.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.2 谓词复合

3.8.3 函数复合

3.9 数学中的类似思想

3.9.1 积分

3.9.2 与 Java 8 的 Lambda 联系起来

3.10 小结

第二部分 使用流进行函数式数据处理

第 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 路线图

4.6 小结

第 5 章 使用流

5.1 筛选

5.1.1 用谓词筛选

5.1.2 筛选各异的元素

5.2 流的切片

5.2.1 使用谓词对流进行切片

5.2.2 截短流

5.2.3 跳过元素

5.3 映射

5.3.1 对流中每一个元素应用函数

5.3.2 流的扁平化

5.4 查找和匹配

5.4.1 检查谓词是否至少匹配一个元素

5.4.2 检查谓词是否匹配所有元素

5.4.3 查找元素

5.4.4 查找第一个元素

5.5 归约

5.5.1 元素求和

5.5.2 最大值和最小值

5.6 付诸实践

5.6.1 领域：交易员和交易

5.6.2 解答

5.7 数值流

5.7.1 原始类型流特化

5.7.2 数值范围

5.7.3 数值流应用：勾股数

5.8 构建流

5.8.1 由值创建流

5.8.2 由可空对象创建流

5.8.3 由数组创建流

5.8.4 由文件生成流

5.8.5 由函数生成流：创建无限流

5.9 概述

5.10 小结

第 6 章 用流收集数据

6.1 收集器简介

6.1.1 收集器用作高级归约

6.1.2 预定义收集器

6.2 归约和汇总

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

6.2.2 汇总

6.2.3 连接字符串

6.2.4 广义的归约汇总

6.3 分组

6.3.1 操作分组的元素

6.3.2 多级分组

6.3.3 按子组收集数据

6.4 分区

6.4.1 分区的优势

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

6.5 收集器接口

6.5.1 理解 Collector 接口声明的方法

6.5.2 全部融合到一起

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

6.6.1 仅用质数做除数

6.6.2 比较收集器的性能

6.7 小结

第 7 章 并行数据处理与性能

7.1 并行流

7.1.1 将顺序流转换为并行流

7.1.2 测量流性能

7.1.3 正确使用并行流

7.1.4 高效使用并行流

7.2 分支/合并框架

7.2.1 使用 RecursiveTask

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

7.2.3 工作窃取

7.3 Spliterator

7.3.1 拆分过程

7.3.2 实现你自己的 Spliterator

7.4 小结

第三部分 使用流和 Lambda 进行高效编程

第 8 章 Collection API 的增强功能

8.1 集合工厂

8.1.1 List 工厂

8.1.2 Set 工厂

8.1.3 Map 工厂

8.2 使用 List 和 Set

8.2.1 removeIf 方法

8.2.2 replaceAll 方法

8.3 使用 Map

8.3.1 forEach 方法

8.3.2 排序

8.3.3 getOrDefault 方法

8.3.4 计算模式

8.3.5 删除模式

8.3.6 替换模式

8.3.7 merge 方法

8.4 改进的 ConcurrentHashMap

8.4.1 归约和搜索

8.4.2 计数

8.4.3 Set 视图

8.5 小结

第 9 章 重构、测试和调试

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

9.1.1 改善代码的可读性

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

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

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

9.1.5 增加代码的灵活性

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

9.2.1 策略模式

9.2.2 模板方法

9.2.3 观察者模式

9.2.4 责任链模式

9.2.5 工厂模式

9.3 测试 Lambda 表达式

9.3.1 测试可见 Lambda 函数的行为

9.3.2 测试使用 Lambda 的方法的行为

9.3.3 将复杂的 Lambda 表达式分为不同的方法

9.3.4 高阶函数的测试

9.4 调试

9.4.1 查看栈跟踪

9.4.2 使用日志调试

9.5 小结

第 10 章 基于 Lambda 的领域特定语言

10.1 领域特定语言

10.1.1 DSL 的优点和弊端

10.1.2 JVM 中已提供的 DSL 解决方案

10.2 现代 Java API 中的小型 DSL

10.2.1 把 Stream API 当成 DSL 去操作集合

10.2.2 将 Collectors 作为 DSL 汇总数据

10.3 使用 Java 创建 DSL 的模式与技巧

10.3.1 方法链接

10.3.2 使用嵌套函数

10.3.3 使用 Lambda 表达式的函数序列

10.3.4 把它们都放到一起

10.3.5 在 DSL 中使用方法引用

10.4 Java 8 DSL 的实际应用

10.4.1 jOOQ

10.4.2 Cucumber

10.4.3 Spring Integration

10.5 小结

第四部分 无所不在的 Java

第 11 章 用 Optional 取代 null

11.1 如何为缺失的值建模

11.1.1 采用防御式检查减少 NullPointerException

11.1.2 null 带来的种种问题

11.1.3 其他语言中 null 的替代品

11.2 Optional 类入门

11.3 应用 Optional 的几种模式

11.3.1 创建 Optional 对象

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

11.3.3 使用 flatMap 链接 Optional 对象

11.3.4 操纵由 Optional 对象构成的 Stream

11.3.5 默认行为及解引用 Optional 对象

11.3.6 两个 Optional 对象的组合

11.3.7 使用 filter 剔除特定的值

11.4 使用 Optional 的实战示例

11.4.1 用 Optional 封装可能为 null 的值

11.4.2 异常与 Optional 的对比

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

11.4.4 把所有内容整合起来

11.5 小结

第 12 章 新的日期和时间 API

12.1 LocalDate、LocalTime、LocalDateTime、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.2 打印输出及解析日期-时间对象

12.3 处理不同的时区和历法

12.3.1 使用时区

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

12.3.3 使用别的日历系统

12.4 小结

第 13 章 默认方法

13.1 不断演进的 API

13.1.1 初始版本的 API

13.1.2 第二版 API

13.2 概述默认方法

13.3 默认方法的使用模式

13.3.1 可选方法

13.3.2 行为的多继承

13.4 解决冲突的规则

13.4.1 解决问题的三条规则

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

13.4.3 冲突及如何显示地消除歧义

13.4.4 菱形继承问题

13.5 小结

第 14 章 Java 模块系统

14.1 模块化的驱动力：软件的推理

14.1.1 关注点分离

14.1.2 信息隐藏

14.1.3 Java 软件

14.2 为什么要设计 Java 模块系统

14.2.1 模块化的局限性

14.2.2 单体型的 JDK

14.2.3 与 OSGi 的比较

14.3 Java 模块：全局视图

14.4 使用 Java 模块系统开发应用

14.4.1 从头开始搭建一个应用

14.4.2 细粒度和粗粒度的模块化

14.4.3 Java 模块系统基础

14.5 使用多个模块

14.5.1 exports 子句

14.5.2 requires 子句

14.5.3 命名

14.6 编译及打包

14.7 自动模块

14.8 模块声明及子句

14.8.1 requires

14.8.2 exports

14.8.3 requires 的传递

14.8.4 exports to

14.8.5 open 和 opens

14.8.6 uses 和 provides

14.9 通过一个更复杂的例子了解更多

14.10 小结

第五部分 提升 Java 的并发性

第 15 章 CompletableFuture 及反应式编程背后的概念

15.1 为支持并发而不断演进的 Java

15.1.1 线程以及更高层的抽象

15.1.2 执行器和线程池

15.1.3 其他的线程抽象：非嵌套方法调用

15.1.4 你希望线程为你带来什么

15.2 同步及异步 API

15.2.1 Future 风格的 API

15.2.2 反应式风格的 API

15.2.3 有害的睡眠及其他阻塞式操作

15.2.4 实战验证

15.2.5 如何使用异步 API 进行异常处理

15.3 “线框-管道”模型

15.4 为并发而生的 CompletableFuture 和结合器

15.5 “发布-订阅”以及反应式编程

15.5.1 示例：对两个流求和

15.5.2 背压

15.5.3 一种简单的真实背压

15.6 反应式系统和反应式编程

15.7 路线图

15.8 小结

第 16 章 CompletableFuture ：组合式异步编程

16.1 Future 接口

16.1.1 Future 接口的局限性

16.1.2 使用 CompletableFuture 构建异步应用

16.2 实现异步 API

16.2.1 将同步方法转换为异步方法

16.2.2 错误处理

16.3 让你的代码免受阻塞之苦

16.3.1 使用并行流对请求进行并行操作

16.3.2 使用 CompletableFuture 发起异步请求

16.3.3 寻找更好的方案

16.3.4 使用定制的执行器

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

16.4.1 实现折扣服务

16.4.2 使用 Discount 服务

16.4.3 构造同步和异步操作

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

16.4.5 对 Future 和 CompletableFuture 的回顾

16.4.6 高效地使用超时机制

16.5 响应 CompletableFuture 的 completion 事件

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

16.5.2 付诸实践

16.6 路线图

16.7 小结

第 17 章 反应式编程

17.1 反应式宣言

17.1.1 应用层的反应式编程

17.1.2 反应式系统

17.2 反应式流以及 Flow API

17.2.1 Flow 类

17.2.2 创建你的第一个反应式应用

17.2.3 使用 Processor 转换数据

17.2.4 为什么 Java 并未提供 Flow API 的实现

17.3 使用反应式库 RxJava

17.3.1 创建和使用 Observable

17.3.2 转换及整合多个 Observable

17.4 小结

第六部分 函数式编程以及 Java 未来的演进

第 18 章 函数式的思考

18.1 实现和维护系统

18.1.1 共享的可变数据

18.1.2 声明式编程

18.1.3 为什么要采用函数式编程

18.2 什么是函数式编程

18.2.1 函数式 Java 编程

18.2.2 引用透明性

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

18.2.4 函数式编程实战

18.3 递归和迭代

18.4 小结

第 19 章 函数式编程的技巧

19.1 无处不在的函数

19.1.1 高阶函数

19.1.2 柯里化

19.2 持久化数据结构

19.2.1 破坏式更新和函数式更新的比较

19.2.2 另一个使用 Tree 的例子

19.2.3 采用函数式的方法

19.3 Stream 的延迟计算

19.3.1 自定义的 Stream

19.3.2 创建你自己的延迟列表

19.4 模式匹配

19.4.1 访问者模式

19.4.2 用模式匹配力挽狂澜

19.5 杂项

19.5.1 缓存或记忆表

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

19.5.3 结合器

19.6 小结

第 20 章 面向对象和函数式编程的混合：Java 和 Scala 的比较

20.1 Scala 简介

20.1.1 你好，啤酒

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

20.2 函数

20.2.1 Scala 中的一等函数

20.2.2 匿名函数和闭包

20.2.3 柯里化

20.3 类和 trait

20.3.1 更加简洁的 Scala 类

20.3.2 Scala 的 trait 与 Java 8 的接口对比

20.4 小结

第 21 章 结论以及 Java 的未来

21.1 回顾 Java 8 的语言特性

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

21.1.2 流

21.1.3 CompletableFuture

21.1.4 Optional

21.1.5 Flow API

21.1.6 默认方法

21.2 Java 9 的模块系统

21.3 Java 10 的局部变量类型推断

21.4 Java 的未来

21.4.1 声明处型变

21.4.2 模式匹配

21.4.3 更加丰富的泛型形式

21.4.4 对不变性的更深层支持

21.4.5 值类型

21.5 让 Java 发展得更快

21.6 写在最后的话

附录 A 其他语言特性的更新

A.1 注解

A.1.1 重复注解

A.1.2 类型注解

A.2 通用目标类型推断

附录 B 其他类库的更新

B.1 集合

B.1.1 其他新增的方法

B.1.2 Collections 类

B.1.3 Comparator

B.2 并发

B.2.1 原子操作

B.2.2 ConcurrentHashMap

B.3 Arrays

B.3.1 使用 parallelSort

B.3.2 使用 setAll 和 parallelSetAll

B.3.3 使用 parallelPrefix

B.4 Number 和 Math

B.4.1 Number

B.4.2 Math

B.5 Files

B.6 Reflection

B.7 String

附录 C 如何以并发方式在同一个流上执行多种操作

C.1 复制流

C.1.1 使用 ForkingStreamConsumer 实现 Results 接口

C.1.2 开发 ForkingStreamConsumer 和 BlockingQueueSpliterator

C.1.3 将 StreamForker 运用于实战

C.2 性能考量

附录 D Lambda 表达式和 JVM 字节码

D.1 匿名类

D.2 生成字节码

D.3 用 InvokeDynamic 力挽狂澜

D.4 代码生成策略