当前位置:主页 > 计算机电子书 > Java > Java8下载
Java 8实战

Java 8实战 PDF 高质量版

  • 更新:2019-09-24
  • 大小:12.9MB
  • 类别:Java8
  • 作者:厄马
  • 出版:人民邮电出版社
  • 格式:PDF

  • 资源介绍
  • 相关推荐

Java 8实战 pdf

Java 8实战》Java 8的公布使Java编程设计产生了天翻地覆的转变。运用Java 8中澳导入的涵数式特点,你能在更短的時间上用更简约的编码进行更繁杂的作用,一起还能灵活运用硬件配置的多核架构。

这书构造清楚、內容详实,从案例下手,包含Java 8的关键新特点,包含Lambda关系式、方式引证、流、默认设置方式、Optional、CompletableFuture及其新的时间和時间API,是程序猿掌握Java 8新特点的**手册。

怎么使用Java 8增加的强劲特点

怎样撰写能合理运用多核架构的程序流程

重新构建、检测和调节

如何高效率地运用函数式编程 

这书全方位详细介绍了Java 8 这一里程碑式版本号的新特点,包含Lambdas、流和函数式编程。拥有涵数式的程序编写特点,能够让编码更简约,一起也可以自动化技术地运用多核硬件配置。本书分4个一部分:基本知识、涵数式数据处理方法、高效率Java 8 程序编写和跨越Java 8,清楚一目了然向用户呈现了一副Java 开拓创新的智能化画轴。

目录

  • 第一部分 基础知识
  • 第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

资源下载

资源下载地址1:https://pan.baidu.com/s/1NdIc_emLuVFWpJGRFrp2CQ

网友留言