找传奇、传世资源到传世资源站!

Java8实战_

8.5玩家评分(1人评分)
下载后可评
介绍 评论 失效链接反馈

Java8实战

简单地说, Java 8中的新增功能是自Java 1.0发布18年以来, Java发生的最大变化。没有去掉任何东西,因此你现有的Java代码都能工作,但新功能提供了强大的新语汇和新设计模式,能帮助你编写更清楚、更简洁的代码。就像遇到所有新功能时那样,你一开始可能会想: “为什么又要去改我的语言呢? ”但稍加练习之后,你就会发觉自己只用预期的一半时间,就用新功能写出了更短、更清晰的代码,这时你会意识到自己永远无法返回到“I日Java”了。本书会帮助你跨过“原理听起来不错,但还是有点儿新,不太适应”的门槛,从而熟练地进行编程。“也许吧,”你可能会想, “可是Lambda、函数式编程,这些不是那些留着胡子、穿着凉鞋的学究们在象牙塔里面琢磨的东西吗? ”或许是的,但Java 8中加入的新想法的分量刚刚好,它们带来的好处也可以被普通的Java程序员所理解。本书会从普通程序员的角度来叙述,偶尔谈谈“这是怎么来的”。“Lambda,听起来跟天书一样!”是的,也许是这样,但它是一个很好的想法,让你可以编写简明的Java程序。许多人都熟悉事件处理器和回调函数,即注册一个对象,它包含会在事件发生时使用的一个方法。Lambda使人更容易在Java中广泛应用这种思想。简单来说, Lambda和它的朋友“方法引用”让你在做其他事情的过程中,可以简明地将代码或方法作为参数传递进去执行。在本书中,你会看到这种思想出现得比预想的还要频繁:从加入作比较的代码来简单地参数化一个排序方法,到利用新的Stream API在一组数据上表达复杂的查询指令。“流(stream)是什么? ”这是Java 8的一个新功能。它们的特点和集合(collection)差不多,但有几个明显的优点,让我们可以使用新的编程风格。首先,如果你使用过SQL等数据库查询语言,就会发现用几行代码写出的查询语句要是换成Java要写好长。Java8的流支持这种简明的数据库查询式编程--但用的是Java语法,而无需了解数据库!其次,流被设计成无需同时将所有的数据调入内存(甚至根本无需计算),这样就可以处理无法装人计算机内存的流数据了。但Java 8可以对流做一些集合所不能的优化操作,例如,它可以将对同一个流的若干操作组合起来,从而只遍历一次数据,而不是花很大代价去多次遍历它。更妙的是,Java可以自动将流操作并行化(集合可不行)。“还有函数式编程,这又是什么? ”就像面向对象编程一样,它是另一种编程风格,其核心是把函数作为值,前面在讨论Lambda的时候提到过。

Java8实战_ Java-第1张Java8实战_ Java-第2张Java8实战_ Java-第3张Java8实战_ Java-第4张Java8实战_ Java-第5张Java8实战_ Java-第6张Java8实战_ Java-第7张Java8实战_ Java-第8张Java8实战_ Java-第9张Java8实战_ Java-第10张Java8实战_ Java-第11张Java8实战_ Java-第12张Java8实战_ Java-第13张Java8实战_ Java-第14张Java8实战_ Java-第15张

目 录

第一部分 基础知识

第 1 章 为什么要关心 Java 8 ....................... 2

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 从传递方法到 Lambda ................. 12

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 在哪里以及如何使用 Lambda ................. 37

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 步:传递 Lambda ................. 42

3.4 使用函数式接口 ...................................... 43

3.4.1 Predicate ................................. 44

3.4.2 Consumer .................................... 44

3.4.3 Function .................................... 45

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

3.5.1 类型检查 ...................................... 49

3.5.2 同样的 Lambda,不同的

函数式接口 .................................. 50

3.5.3 类型推断 ...................................... 512 目 录

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目 录 3

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

18

17

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 使用 RecursiveTask .............. 149

7.2.2 使用分支/合并框架的

最佳做法 .................................... 153

7.2.3 工作窃取 .................................... 154

7.3 Spliterator ....................................... 155

7.3.1 拆分过程 .................................... 155

7.3.2 实现你自己的 Spliterator ... 157

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 从命令式的数据处理切换到

Stream ........................................ 167

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 初始版本的 API ......................... 188

9.1.2 第二版 API ................................ 188

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 取代 null .......... 202

10.1 如何为缺失的值建模........................... 203

10.1.1 采用防御式检查减少 Null

PointerException ............. 2034 目 录

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 章 新的日期和时间 API ............... 246

12.1 LocalDate、LocalTime、Instant、

Duration 以及 Period .................... 247

12.1.1 使用 LocalDate 和

LocalTime ........................... 247

12.1.2 合并日期和时间 ..................... 248

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

12.1.4 定义 Duration 或

Period .................................. 249

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

12.2.1 使用 TemporalAdjuster .... 253

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目 录 5

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

18

17

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

以及 Option .......................... 302

15.2 函数 ..................................................... 306

15.2.1 Scala 中的一等函数 ............... 307

15.2.2 匿名函数和闭包 ..................... 307

15.2.3 科里化 .................................... 309

15.3 类和 trait .............................................. 310

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 CompletableFuture .......... 315

16.1.4 Optional .............................. 315

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 第一部分

评论

发表评论必须先登陆, 您可以 登陆 或者 注册新账号 !


在线咨询: 问题反馈
客服QQ:174666394

有问题请留言,看到后及时答复