Java 8实战

出版者:人民邮电出版社

作者:厄马(Raoul-Gabriel Urma)

页数:349

译者:陆明刚

出版时间:2016-4-1

价格:CNY 79.00

装帧:平装

isbn号码:9787115419347

丛书系列:图灵程序设计丛书·Java系列

具体描述

本书全面介绍了Java 8 这个里程碑版本的新特性，包括Lambdas、流和函数式编程。有了函数式的编程特性，可以让代码更简洁，同时也能自动化地利用多核硬件。全书分四个部分：基础知识、函数式数据处理、高效Java 8 编程和超越Java 8，清晰明了地向读者展现了一幅Java 与时俱进的现代化画卷。

作者简介

作者简介：

Raoul-Gabriel Urma

剑桥大学计算机科学博士，软件工程师，演讲者，培训师，Cambridge Coding Academy联合创始人、CEO。曾与谷歌、eBay、甲骨文和高盛集团等大公司合作，并参与过多个创业项目。撰写过十余篇经同行审阅的技术文章，并在国际会议上发表过40多篇演讲。

Mario Fusco

Red Hat高级软件工程师，负责JBoss规则引擎Drools的核心开发。拥有丰富的Java开发经验，曾领导媒体公司、金融部门等多个行业的企业级项目开发。对函数式编程和领域特定语言等有浓厚兴趣，并创建了开放源码库lambdaj。

Alan Mycroft

剑桥大学计算机实验室计算学教授，剑桥大学罗宾逊学院研究员，欧洲编程语言和系统协会联合创始人，树莓派基金会联合创始人和理事。发表过大约100篇研究论文，指导过20多篇博士论文。他的研究主要关注编程语言及其语义、优化和实施。他与业界联系紧密，曾于学术休假期间在AT&T实验室和英特尔工作，还创立了Codemist公司，该公司设计了最初的ARM C编译器Norcroft。

译者简介：

陆明刚

毕业于四川大学，目前在EMC中国卓越研发集团任首席工程师，曾任趋势科技中国软件研发中心技术经理，在信息科学和工程领域有十余年的实践和研究经验，拥有多项中国及美国专利。关注JVM性能调优和大数据及其实践，喜欢挖掘技术背后的内幕并乐此不疲。

劳佳

硕士毕业于上海交通大学，现在SAP美国任高级软件支持顾问。业余爱好语言、数学、设计，近年翻译出版了《咨询的奥秘》《卓越程序员密码》等书。

目录信息

第一部分 基础知识
第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　类型推断　　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　使用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　　203
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
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
· · · · · · (收起)

读后感

这点东西根本不值当写成一本书。 几篇连续的博客足以完成这个任务，这个任务适合写成几篇连续的博客。 一本书的内容应该比这个多比这个深。比这个多比这个深的内容才适合写成一本书。 一定要多写文字凑够评论字数要求，为了凑够评论字数要求多写了这些无用的话。 其实我想说的...

用户评价

作为一名在Java领域摸爬滚打多年的开发者，我深知学习新技术的重要性，但同时我也清楚，很多技术书籍往往流于表面，难以真正触及问题的核心。《Java 8实战》这本书，给我带来了不一样的体验。它并没有一上来就抛出大量的代码，而是先深入浅出地讲解了Java 8引入的革命性特性，例如lambda表达式和函数式接口的由来以及它们带来的深远影响。作者的笔触非常细腻，能够将复杂的技术概念用通俗易懂的语言表达出来，让人在轻松的阅读氛围中逐渐领悟。最令我赞赏的是，这本书在讲解Stream API时，不仅仅是罗列了各种操作符，而是将其视为一种强大的数据处理管道，并详细阐述了其背后的优化机制和使用技巧，让我能够写出既简洁又高效的代码。此外，书中还探讨了Optional类在提升代码健壮性方面的作用，以及Java 8在并发编程方面的新进展，这些都是我工作中经常会遇到的挑战，这本书为我提供了宝贵的解决方案。总而言之，这是一本真正能够帮助开发者提升实战能力的优秀书籍。

作为一名资深的Java开发者，我一直在寻找能够真正提升代码质量和开发效率的工具和技术。《Java 8实战》这本书，可以说是完全满足了我的期待，甚至超出了我的预期。这本书最让我印象深刻的是其对函数式编程思想的深刻阐述和在Java 8中的具体实践。作者并没有将函数式编程讲得高不可攀，而是通过生动的比喻和简洁的例子，将原本抽象的概念变得通俗易懂。它帮助我理解了为什么函数式编程能够带来更清晰、更易于维护的代码，以及如何在实际项目中规避并发编程中的许多陷阱。特别是Stream API部分，我以前在处理大量数据时，总是会写一大堆嵌套的循环和条件判断，代码冗长且容易出错。读完这本书后，我学会了用Stream API以一种声明式的方式来处理集合，代码瞬间变得简洁高效，可读性也大大提高。Optional类的使用更是解决了Java中“空指针异常”这一老大难问题，让我的代码更加健壮。这本书让我重新审视了Java语言本身，也拓宽了我的技术视野。我发现，掌握这些现代化的编程范式，不仅能提升我个人的技术能力，更能对团队的开发效率和项目质量产生积极的影响。

坦白讲，一开始我抱着尝试的心态翻开《Java 8实战》，毕竟很多Java 8的教程都倾向于讲解语法，而我更希望了解背后的设计哲学和实际应用价值。幸运的是，这本书完全没有让我失望。它并非简单的技术堆砌，而是将Java 8的各个特性有机地串联起来，形成了一个完整的知识体系。作者的讲解逻辑非常严谨，每一个概念的引入都建立在对前一个概念的理解之上，使得学习过程连贯且高效。尤其是在处理并发和函数式编程方面，这本书提供了一个非常好的切入点。它让我明白，函数式编程并非是Java独有的，而是软件开发中的一种重要范式，而Java 8为我们提供了实现这一范式的强大工具。书中的案例都非常具有代表性，涵盖了从数据处理到异步编程的各种场景，让我能够清晰地看到这些新特性如何在实际开发中发挥作用，解决实际问题。读完这本书，我不仅掌握了Java 8的核心特性，更重要的是，我开始学会用一种更现代、更高效的方式来思考和编写Java代码。

我必须说，《Java 8实战》这本书的内容对我来说就像是打开了新世界的大门。在阅读之前，我对Java 8的一些新特性，比如lambda表达式和Stream API，只是有所耳闻，知道它们能让代码更简洁，但具体怎么用，用在哪里，一直是个模糊的概念。这本书的讲解，简直是把我从一个“只知其名”的状态，带到了一个“知其所以然，更知其所以然”的境界。作者的写作风格非常注重细节，每一个新特性的引入，都会先说明它解决了什么痛点，然后通过清晰的代码示例展示如何使用。最让我喜欢的是，书中不仅仅停留在“怎么用”的层面，而是深入探讨了“为什么这样用”以及“这样用有什么好处”。比如，在讲到Stream API的时候，作者不仅给出了各种操作的用法，还详细解释了其背后的惰性求值和并行处理的原理，让我理解了为什么它能如此高效。此外，书中还涉及了一些关于Java内存模型和并发编程的内容，这些都是我一直以来比较头疼但又至关重要的知识点，作者的讲解让我豁然开朗，感觉自己的Java功底又扎实了不少。

这本《Java 8实战》真是我近期读过最让我惊喜的一本书了！刚拿到手的时候，我还有点担心，毕竟“实战”两个字听起来就意味着枯燥的代码和理论，但事实证明我的担忧完全是多余的。作者的讲解方式太棒了，完全不像我以前读过的那些技术书籍，枯燥乏味，让人昏昏欲睡。相反，这本书的语言流畅自然，仿佛在和一位经验丰富的技术大神面对面交流。书中举的例子都非常贴合实际开发中的场景，我常常能从中看到自己过去项目中遇到的问题，以及作者是如何巧妙地运用Java 8的新特性来解决的。更重要的是，它不仅仅是罗列新特性，而是深入剖析了这些特性背后的设计理念和潜在的优势，让我不仅知其然，更知其所以然。读完之后，我感觉自己对Java的理解上升了一个新的维度，很多之前模糊的概念都变得清晰起来，甚至能主动思考如何在未来的项目中应用这些新知识。这种“顿悟”的感觉，对于一个程序员来说，简直是无价之宝。这本书的结构也非常清晰，逻辑性很强，从基础的lambda表达式到函数式接口，再到Stream API和Optional，层层递进，循序渐进，一点都不觉得吃力。即使我不是Java 8的专家，也能很快跟上作者的思路，并且在学习过程中不断获得成就感。

大部分内容浅显易懂，有趣的内容就少些了。了解Java8的函数式编程相关内容。

大量借鉴 Scala 的 Java8 终于可以让程序写的不那么繁琐了，Stream, CompletableFuture 等都让人眼前一亮。事实上，虽然写起来啰嗦，但 Java 从来都是一门不差的语言，只是框架和社区一直把人往沟里带

- java8实战(java8 in action): 结构清晰、内容翔实，从实例入手，涵盖 Java 8 的主要新特性，包括Lambda表达式、方法引用、流、默认方法、Optional、CompletableFuture 以及新的日期和时间 API

清晰又明确

Java 8提供的函数式编程能力意义不亚于Java 7的并发类库，Stream流处理就是单机版的Spark，还有CompleteFuture和JS里的Promise真是异曲同工。