标签分类
当前位置:首页 > 程序设计电子书 > Java8电子书网盘下载
Java 8实战 Java 8实战
luyongmin

luyongmin 提供上传

资源
22
粉丝
39
喜欢
132
评论
15

    Java 8实战 PDF 高质量版

    Java8电子书
    • 发布时间:

    给大家带来的一篇关于Java8相关的电子书资源,介绍了关于Java8、实战方面的内容,本书是由人民邮电出版社出版,格式为PDF,资源大小12.9MB,厄马编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:7.9,更多相关的学习资源可以参阅 程序设计电子书Java电子书、等栏目。

  • Java 8实战 PDF 下载
  • 下载地址:https://pan.baidu.com/s/1NdIc_emLuVFWpJGRFrp2CQ
  • 分享码:qxk4
  • 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

    上一篇:科学的极致:漫谈人工智能  下一篇:Python树莓派编程

    展开 +

    收起 -

    码小辫二维码
     ←点击下载即可登录

    Java8相关电子书
    学习笔记
    网友NO.845065

    Kotlin 接口与 Java8 新特性接口详解

    前言 在看一本关于高性能编程的时候发现 Java8 中关于接口的新特性的介绍,这个特性是真的棒,解决了一个接口中有多个方法,但并不想实现该接口的类都去实现所有的方法,简单的说就是在类需要的情况再去重写接口。所以有了以下的特性出现。 接口增强 在 Java8 的中接口特性中增加以下俩种特性: 在接口中可以使用 default 关键字修饰默认方法或扩展方法,抽象方法因为其特性的原因无法使用 接口可以使用 static 声明为静态方法,可以通过类直接调用Android Studio 中使用 Java8 需要在模块中的 build.gradle 中配置指定的版 Java 版本,当然使用 Kotlin 为开发语言的话需要为 Kotlin 指定 Jvm 版本,因为 Kotlin 使用的是 Jvm 1.6 那么下面就来展示他们的配置方法: android {defaultConfig {... kotlinOptions {jvmTarget = '1.8'}}compileOptions {sourceCompatibility JavaVersion.VERSION_1_8targetCompatibility JavaVersion.VERSION_1_8}} 经过以上的配置就可以使用 Java8 的新特性了代码示例: puclic interface onTest{void onTestStandardMenthod();default void onTestDefaultMethond(){// 默认的逻辑}static void onTestStaticMenthod(){// 默认的逻辑}}public class TestActivity extends AppCompatActivity implements onTest{@Overrideprotected void onCreate(@Nullable Bundle savedInstanceState) {super.onCreate(savedInstanceState);// 通过类名调用的接口onTest.onTestStaticMentho……

    网友NO.678347

    Java8新特性Stream流实例详解

    什么是Stream流? Stream流是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。 Stream的优点:声明性,可复合,可并行。这三个特性使得stream操作更简洁,更灵活,更高效。 Stream的操作有两个特点:可以多个操作链接起来运行,内部迭代。 Stream可分为并行流与串行流,Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。串行流就不必再细说了,并行流主要是为了为了适应目前多核机器的时代,提高系统CPU、内存的利用率,并行流就是把一个内容分成多个数据块,并用不同的线程分别处理每个数据块的流。java1.8并行流使用的是fork/join框架,关于fork/join框架可参考http://ifeve.com/talk-concurrency-forkjoin/学习。 注意 : * 1、Stream不会自己存储数据。 * 2、Stream不会改变原对象,他们会返回一个新的Stream。 * 3、Stream操作是延迟的,他们会等到需要的结果时才执行。 * 4、使用并行流并不一定会提高效率,因为jvm对数据进行切片和切换线程也是需要时间的。 本文主要讲 Stream的3个操作步骤:1、创建Stream 2、中间操作3、终止操作。 创建Stream 创建Stream,就是将一个数据源 (如:集合、数组)转化为一个流。 1、通过Collection系列提供的stream()(串行) 或parallelStream()(并行)获取数据流。 2、通过Ar……

    网友NO.806613

    在centos7下安装和部署java8和mysql

    一般学习java和部署项目都是在本地部署,但是生产环境一般都是在linux环境下,部署和安装环境都是在控制台下进行操作的,没有windows的可视化的操作界面,对与linux的命令掌握和操作对小白来说都是一个个挑战,记录下自己的安装配置过程,以便自己和大家一起学习: 登陆远程服务器,个人使用所以用的是root,输入自己的密码 ssh -i ~/.ssh/id_rsa root@ip 安装java8 我的服务器是有yum的,所以绝大部分的东西,用的上yum来安装的,类似mac os上面的homebrew,安装配置相对简单。 首先我们看看yum里面有那些java的版本: yum -y list java* 之后可以看到一系列的java1.6,1.7,1.8的,你可以选择你要的版本进行安装,本人安装的是1.8的: yum -y install java-1.8.0-openjdk* 一路很顺畅,会提示一个 完毕! 接下来验证java版本看看是否安装完成: java -versionopenjdk version "1.8.0_121"OpenJDK Runtime Environment (build 1.8.0_121-b13)OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode) 好的,这个时候我们的java8基本上安装成功了!接下来,安装我们的mysql: mysql安装 首先下载安装包,这个过程要看你服务器的网速了: wget http://repo.mysql.com/mysql-community-release-el7-5.noarch.rpm 再接着安装mysql包: sudo rpm -ivh mysql-community-release-el7-5.noarch.rpm 完了之后你就可以安装mysql了: sudo yum install mysql-server 一……

    网友NO.833200

    Java8 用Lambda表达式给List集合排序的实现

    Lambda用到了JDK8自带的一个函数式接口ComparatorT。 准备一个Apple类 public class Apple { private int weight; private String color; public Apple(){} public Apple(int weight) { this.weight = weight; } public Apple(int weight, String color) { this.weight = weight; this.color = color; } setters();getters();toString(); } 步骤一: public class AppleComparator implements ComparatorApple { @Override public int compare(Apple o1, Apple o2) { return o1.getWeight() - o2.getWeight(); }} 步骤二:准备一个List集合 ArrayListApple inventory = Lists.newArrayList( new Apple(10, "red"), new Apple(5, "red"), new Apple(1, "green"), new Apple(15, "green"), new Apple(2, "red")); 步骤三:顺序排序,三种方式 /** * 顺序排序 */// 1、传递代码,函数式编程inventory.sort(new AppleComparator());System.out.println(inventory);// 2、匿名内部类inventory.sort(new ComparatorApple() { @Override public int compare(Apple o1, Apple o2) { return o1.getWeight() - o2.getWeight(); }});// 3、使用Lambda表达式inventory.sort((a, b) - a.getWeight() - b.getWeight());// 4、使用Comparator的comparingComparatorApple comparing = comparing((Apple a) - a.getWeight());inventory.sort(comparing((Apple a) - a.getWeight()));//或者等价于inventory.sort(comparing(Apple::getWeight)); 步骤四:逆序排序 /** * 逆序排序 */// 1、 根据重量逆序排序inventory.sort(comparing(Apple::getWeight).reversed()); 步骤五:如果两个苹果一样重,就得再找……

    Copyright 2018-2019 xz577.com 码农之家

    版权责任说明