Java 8实战

第一部分 基础知识

第1章　为什么要关心Java 82

1.1　Java怎么还在变4

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

1...

第一部分 基础知识

第1章　为什么要关心Java 82

1.1　Java怎么还在变4

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

1.1.2　流处理6

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

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

1.1.5　Java需要演变8

1.2　Java中的函数8

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

1.2.2　传递代码：一个例子11

1.2.3　从传递方法到Lambda12

1.3　流13

1.4　默认方法17

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

1.6　小结19

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

2.1　应对不断变化的需求21

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

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

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

2.2　行为参数化23

2.3　对付啰嗦27

2.3.1　匿名类28

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

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

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

2.4　真实的例子31

2.4.1　用Comparator来排序31

2.4.2　用Runnable执行代码块32

2.4.3　GUI事件处理32

2.5　小结33

第3章　Lambda表达式34

3.1　Lambda管中窥豹35

3.2　在哪里以及如何使用Lambda37

3.2.1　函数式接口37

3.2.2　函数描述符39

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

3.3.1　第1步记得行为参数化41

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

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

3.3.4　第4步：传递Lambda42

3.4　使用函数式接口43

3.4.1　Predicate44

3.4.2　Consumer44

3.4.3　Function45

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

3.5.1　类型检查49

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

3.5.3　类型推断51

3.5.4　使用局部变量52

3.6　方法引用53

3.6.1　管中窥豹53

3.6.2　构造函数引用55

3.7　Lambda和方法引用实战57

3.7.1　第1步：传递代码58

3.7.2　第2步：使用匿名类58

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

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

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

3.8.1　比较器复合60

3.8.2　谓词复合60

3.8.3　函数复合61

3.9　数学中的类似思想62

3.9.1　积分62

3.9.2　与Java 8的Lambda联系起来63

3.10　小结64

第二部分 函数式数据处理

第4章　引入流68

4.1　流是什么68

4.2　流简介72

4.3　流与集合74

4.3.1　只能遍历一次75

4.3.2　外部迭代与内部迭代76

4.4　流操作78

4.4.1　中间操作78

4.4.2　终端操作79

4.4.3　使用流80

4.5　小结81

第5章　使用流82

5.1　筛选和切片83

5.1.1　用谓词筛选83

5.1.2　筛选各异的元素83

5.1.3　截短流84

5.1.4　跳过元素85

5.2　映射86

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

5.2.2　流的扁平化87

5.3　查找和匹配90

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

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

5.3.3　查找元素91

5.3.4　查找第一个元素92

5.4　归约92

5.4.1　元素求和93

5.4.2　最大值和最小值94

5.5　付诸实践97

5.5.1　领域：交易员和交易98

5.5.2　解答99

5.6　数值流101

5.6.1　原始类型流特化101

5.6.2　数值范围102

5.6.3　数值流应用：勾股数103

5.7　构建流105

5.7.1　由值创建流106

5.7.2　由数组创建流106

5.7.3　由文件生成流106

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

5.8　小结110

第6章　用流收集数据111

6.1　收集器简介112

6.1.1　收集器用作高级归约112

6.1.2　预定义收集器113

6.2　归约和汇总114

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

6.2.2　汇总115

6.2.3　连接字符串116

6.2.4　广义的归约汇总117

6.3　分组120

6.3.1　多级分组121

6.3.2　按子组收集数据122

6.4　分区126

6.4.1　分区的优势126

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

6.5　收集器接口129

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

6.5.2　全部融合到一起134

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

6.6.1　仅用质数做除数136

6.6.2　比较收集器的性能139

6.7　小结140

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

7.1　并行流141

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

7.1.2　测量流性能144

7.1.3　正确使用并行流147

7.1.4　高效使用并行流148

7.2　分支/合并框架149

7.2.1　使用RecursiveTask149

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

7.2.3　工作窃取154

7.3　Spliterator155

7.3.1　拆分过程155

7.3.2　实现你自己的Spliterator157

7.4　小结162

第三部分 高效Java 8编程

第8章　重构、测试和调试164

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

8.1.1　改善代码的可读性165

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

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

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

8.1.5　增加代码的灵活性168

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

8.2.1　策略模式171

8.2.2　模板方法172

8.2.3　观察者模式173

8.2.4　责任链模式175

8.2.5　工厂模式177

8.3　测试Lambda表达式178

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

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

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

8.3.4　高阶函数的测试180

8.4　调试181

8.4.1　查看栈跟踪181

8.4.2　使用日志调试183

8.5　小结184

第9章　默认方法 185

9.1　不断演进的API 187

9.1.1　初始版本的API188

9.1.2　第二版API188

9.2　概述默认方法190

9.3　默认方法的使用模式192

9.3.1　可选方法192

9.3.2　行为的多继承192

9.4　解决冲突的规则196

9.4.1　解决问题的三条规则196

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

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

9.4.4　菱形继承问题200

9.5　小结201

第10章　用Optional取代null202

10.1　如何为缺失的值建模 203

10.1.1　采用防御式检查减少Null-PointerException203

10.1.2　null带来的种种问题204

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

10.2　Optional类入门206

10.3　应用Optional的几种模式 207

10.3.1　创建Optional对象208

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

10.3.3　使用flatMap链接Optional对象209

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

10.3.5　两个Optional对象的组合213

10.3.6　使用filter剔除特定的值214

10.4　使用Optional的实战示例 216

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

10.4.2　异常与Optional的对比217

10.4.3　把所有内容整合起来218

10.5　小结219

第11章　CompletableFuture：组合式异步编程220

11.1　Future接口222

11.1.1　Future接口的局限性223

11.1.2　使用CompletableFuture构建异步应用223

11.2　实现异步API 224

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

11.2.2　错误处理227

11.3　让你的代码免受阻塞之苦228

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

11.3.2　使用CompletableFuture发起异步请求230

11.3.3　寻找更好的方案232

11.3.4　使用定制的执行器233

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

11.4.1　实现折扣服务235

11.4.2　使用Discount服务236

11.4.3　构造同步和异步操作237

11.4.4　将两个Completable-Future对象整合起来，无论它们是否存在依赖239

11.4.5　对Future和Completable-Future的回顾241

11.5　响应CompletableFuture的completion事件242

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

11.5.2　付诸实践244

11.6　小结245

第12章　新的日期和时间API246

12.1　LocalDate、LocalTime、Instant、Duration以及Period247

12.1.1　使用LocalDate和LocalTime247

12.1.2　合并日期和时间248

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

12.1.4　定义Duration或Period249

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

12.2.1　使用TemporalAdjuster253

12.2.2　打印输出及解析日期－时间对象255

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

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

12.3.2　使用别的日历系统258

12.4　小结259

第四部分 超越Java 8

第13章　函数式的思考262

13.1　实现和维护系统262

13.1.1　共享的可变数据263

13.1.2　声明式编程264

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

13.2　什么是函数式编程265

13.2.1　函数式Java编程266

13.2.2　引用透明性268

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

13.2.4　函数式编程实战269

13.3　递归和迭代271

13.4　小结274

第14章　函数式编程的技巧275

14.1　无处不在的函数275

14.1.1　高阶函数275

14.1.2　科里化277

14.2　持久化数据结构278

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

14.2.2　另一个使用Tree的例子281

14.2.3　采用函数式的方法282

14.3　Stream的延迟计算283

14.3.1　自定义的Stream 283

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

14.4　模式匹配290

14.4.1　访问者设计模式291

14.4.2　用模式匹配力挽狂澜292

14.5　杂项295

14.5.1　缓存或记忆表295

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

14.5.3　结合器296

14.6　小结297

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

15.1　Scala简介300

15.1.1　你好，啤酒300

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

15.2　函数306

15.2.1　Scala中的一等函数307

15.2.2　匿名函数和闭包307

15.2.3　科里化309

15.3　类和trait310

15.3.1　更加简洁的Scala类310

15.3.2　Scala的trait与Java 8的接口对比311

15.4　小结312

第16章　结论以及Java的未来313

16.1　回顾Java 8的语言特性 313

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

16.1.2　流314

16.1.3　CompletableFuture315

16.1.4　Optional315

16.1.5　默认方法316

16.2　Java 的未来316

16.2.1　集合316

16.2.2　类型系统的改进317

16.2.3　模式匹配318

16.2.4　更加丰富的泛型形式319

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

16.2.6　值类型322

16.3　写在最后的话325

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

附录B　类库的更新330

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

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

编程语言中的函数一词通常是指方法，尤其是静态方法；这是在数学函数，也就是没有副作用的函数之外的新含义。幸运的是，你将会看到，在Java 8谈到函数时，这两种用法几乎是一致的。 Java 8中新增了函数——值的一种新形式。它有助于使用1.3节中谈到的流，有了它，Java 8可以进行多核处理器上的并行编程。我们首先来展示一下作为值的函数本身的有用之处。 想想Java程序可能操作的值吧。首先...

(查看全部试读)