出版社: 人民邮电出版社
译者: 王群锋
出版年: 2015-3
页数: 148
定价: 39.00元
装帧: 平装
丛书: 图灵程序设计丛书·Java系列
ISBN: 9787115384881
内容简介 · · · · · ·
通过每一章的练习快速掌握Java 8中的Lambda表达式
分析流、高级集合和其他Java 8类库的改进
利用多核CPU提高数据并发的性能
将现有代码库和库代码Lambda化
学习Lambda表达式单元测试和调试的实践解决方案
用Lambda表达式实现面向对象编程的SOLID原则
编写能有效执行消息传送和非阻塞I/O的并发应用
作者简介 · · · · · ·
作者简介:
Richard Warburton
一位经验丰富的技术专家,善于解决复杂深奥的技术问题,拥有华威大学计算机科学专业博士学位。近期他一直从事高性能计算方面的数据分析工作。他是英国伦敦Java社区的领导者,组织过面向Java 8中Lambda表达式、日期和时间的Adopt-a-JSR项目,以及Openjdk Hackdays活动。Richard还是知名的会议演讲嘉宾,曾在JavaOne、DevoxxUK和JAX London等会议上演讲。
译者简介:
王群锋
毕业于西安电子科技大学,现任职于IBM西安研发中心,从事下一代统计预测软件的开发运维工作。
目录 · · · · · ·
第1章 简介 1
1.1 为什么需要再次修改Java 1
1.2 什么是函数式编程 2
1.3 示例 2
第2章 Lambda 表达式 5
2.1 第一个Lambda 表达式 5
2.2 如何辨别Lambda 表达式 6
2.3 引用值,而不是变量 8
2.4 函数接口 9
2.5 类型推断 10
2.6 要点回顾 12
2.7 练习 12
第3章 流 15
3.1 从外部迭代到内部迭代 15
3.2 实现机制 17
3.3 常用的流操作 19
3.3.1 collect(toList()) 19
3.3.2 map 19
3.3.3 filter 21
3.3.4 flatMap 22
3.3.5 max 和min 23
3.3.6 通用模式 24
3.3.7 reduce 24
3.3.8 整合操作 26
3.4 重构遗留代码 27
3.5 多次调用流操作 30
3.6 高阶函数 31
3.7 正确使用Lambda 表达式 31
3.8 要点回顾 32
3.9 练习 32
3.10 进阶练习 33
第4章 类库 35
4.1 在代码中使用Lambda 表达式 35
4.2 基本类型 36
4.3 重载解析 38
4.4 @FunctionalInterface 40
4.5 二进制接口的兼容性 40
4.6 默认方法 41
4.7 多重继承 45
4.8 权衡 46
4.9 接口的静态方法 46
4.10 Optional 47
4.11 要点回顾 48
4.12 练习 48
4.13 开放练习 49
第5章 高级集合类和收集器 51
5.1 方法引用 51
5.2 元素顺序 52
5.3 使用收集器 54
5.3.1 转换成其他集合 54
5.3.2 转换成值 55
5.3.3 数据分块 55
5.3.4 数据分组 56
5.3.5 字符串 57
5.3.6 组合收集器 58
5.3.7 重构和定制收集器 60
5.3.8 对收集器的归一化处理 65
5.4 一些细节 66
5.5 要点回顾 67
5.6 练习 67
第6章 数据并行化 69
6.1 并行和并发 69
6.2 为什么并行化如此重要 70
6.3 并行化流操作 71
6.4 模拟系统 72
6.5 限制 75
6.6 性能 75
6.7 并行化数组操作 78
6.8 要点回顾 80
6.9 练习 80
第7章 测试、调试和重构 81
7.1 重构候选项 81
7.1.1 进进出出、摇摇晃晃 82
7.1.2 孤独的覆盖 82
7.1.3 同样的东西写两遍 83
7.2 Lambda 表达式的单元测试 85
7.3 在测试替身时使用Lambda 表达式 87
7.4 惰性求值和调试 89
7.5 日志和打印消息 89
7.6 解决方案:peak 90
7.7 在流中间设置断点 90
7.8 要点回顾 90
第8章 设计和架构的原则 91
8.1 Lambda 表达式改变了设计模式 92
8.1.1 命令者模式 92
8.1.2 策略模式 95
8.1.3 观察者模式 97
8.1.4 模板方法模式 100
8.2 使用Lambda 表达式的领域专用语言 102
8.2.1 使用Java 编写DSL 103
8.2.2 实现 104
8.2.3 评估 106
8.3 使用Lambda 表达式的SOLID 原则 106
8.3.1 单一功能原则 107
8.3.2 开闭原则 109
8.3.3 依赖反转原则 111
8.4 进阶阅读 114
8.5 要点回顾 114
第9章 使用Lambda 表达式编写并发程序 115
9.1 为什么要使用非阻塞式I/O 115
9.2 回调 116
9.3 消息传递架构 119
9.4 末日金字塔 120
9.5 Future 122
9.6 CompletableFuture 123
9.7 响应式编程 126
9.8 何时何地使用新技术 128
9.9 要点回顾 129
9.10 练习 129
第10章 下一步该怎么办 131
封面介绍 133
· · · · · · (收起)
丛书信息
喜欢读"Java 8函数式编程"的人也喜欢的电子书 · · · · · ·
喜欢读"Java 8函数式编程"的人也喜欢 · · · · · ·
Java 8函数式编程的话题 · · · · · · ( 全部 条 )



Java 8函数式编程的书评 · · · · · · ( 全部 4 条 )

最近又拿出了这本书想看看

《java 8函数式编程》笔记
这篇书评可能有关键情节透露
#lambda lambda将行为像数据一样传递。 影响性能五个要素:数据大小,源数据结构,值是否装箱,可用的cpu数量,处理每个元素花的时间。 测试lambda需要将重点放在行为上。 lambda单元测试:抽取成为一个具名方法。 peek可以记录中间值,利于调试。 #设计模式 命令者模式 使用对... (展开)
初步了解Java8中的lambda编程
这篇书评可能有关键情节透露
本书虽然是讲Java8中的lambda表达式,但是书中并没有详细的介绍有关lambda表达式的知识,读者最好学习过lambda的相关知识,至少要知道什么是lambda表达式。 java8中引入了lambda表达式,使java有了函数式编程的语法特征。相较于java6,7并没有对类库有较大的更改,... (展开)> 更多书评 4篇
-
2.ThreadLocal Lambda表达式。Java有一个ThreadLocal类,作为容器保存了当前线程里局部变量的值。Java 8为该类新加了一个工厂方法,接受一个Lambda表达式,并产生一个新的ThreadLocal对象,而不用使用继承,语法上更加简洁。 a. 在Javadoc或集成开发环境(IDE)里找出该方法。 b. DateFormatter类是非线程安全的。使用构造函数创建一个线程安全的DateFormatter对象,并输出日期,如“01-Jan-1970”。 ThreadLocal<DateFormat... (1回应)
2016-07-20 21:07:02 1人喜欢
2.ThreadLocal Lambda表达式。Java有一个ThreadLocal类,作为容器保存了当前线程里局部变量的值。Java 8为该类新加了一个工厂方法,接受一个Lambda表达式,并产生一个新的ThreadLocal对象,而不用使用继承,语法上更加简洁。 a. 在Javadoc或集成开发环境(IDE)里找出该方法。 b. DateFormatter类是非线程安全的。使用构造函数创建一个线程安全的DateFormatter对象,并输出日期,如“01-Jan-1970”。
ThreadLocal<DateFormatter> threadLocal = ThreadLocal .withInitial(() -> new DateFormatter(new SimpleDateFormat("dd-MMM-yyyy"))); System.out.println(threadLocal.get().valueToString(new Date()));
1回应 2016-07-20 21:07:02 -
曾小展同学 (冲鸭)
1. 方法引用就是类名称 :: 方法,这种方式比lambda更直 2. 流是否有序,取决与集合是否有序以及对流的操作,例如List是有序,Set是无序的,可以使用sort等方式对流进行排序。 3. 收集器:将收集器传给collect(),就可以生成其他流,比如 (1) 转换为自己想要的集合,使用toCollection(TreeSet::new) (2) 生成一个值:maxBy 和 minBy ,averagingInt 等 (3) 数据分块和分组:partitioningBy 和 groupingby (4) 字符串:joining 连...2020-05-28 13:38:13
1. 方法引用就是类名称 :: 方法,这种方式比lambda更直
2. 流是否有序,取决与集合是否有序以及对流的操作,例如List是有序,Set是无序的,可以使用sort等方式对流进行排序。
3. 收集器:将收集器传给collect(),就可以生成其他流,比如
(1) 转换为自己想要的集合,使用toCollection(TreeSet::new)
(2) 生成一个值:maxBy 和 minBy ,averagingInt 等
(3) 数据分块和分组:partitioningBy 和 groupingby
(4) 字符串:joining 连接
4. 组合收集器的意思是告诉收集器,你用另外一个收集器收集结果。例如list.collect(groupingBy(funciton , counting)),常用的有counting、mapping
5. 重构和定制收集器,通过实现Collector接口来实现,例如,需要一个新的收集器来输出字符串,而不是joining,有一点类似hadoop里面写mapreduce,定义好输入和输出,同时定义好收集器,针对收集器实现对应的supplier、accumulator、combiner、finisher,以及characterstist接口
回应 2020-05-28 13:38:13 -
Strangeen (很懒,什么都没留下)
1. 只用reduce 和Lambda 表达式写出实现Stream 上的map 操作的代码,如果不想返回Stream,可以返回一个List。 2. 只用reduce 和Lambda 表达式写出实现Stream 上的filter 操作的代码,如果不想返回Stream,可以返回一个List。 答案见:[http://www.jianshu.com/p/bec12aa21fc6]2017-11-04 00:28:25
1. 只用reduce 和Lambda 表达式写出实现Stream 上的map 操作的代码,如果不想返回Stream,可以返回一个List。 2. 只用reduce 和Lambda 表达式写出实现Stream 上的filter 操作的代码,如果不想返回Stream,可以返回一个List。 引自 3.10进阶练习 答案见:http://www.jianshu.com/p/bec12aa21fc6
回应 2017-11-04 00:28:25
-
Q: 为什么要会有Java 8? A: 适应现代多核CPU,让代码在多核CPU上高效运行。 面向对象编程是对数据进行抽象,而函数式编程是对行为进行抽象。 以前传递行为的方式是传递拥有具有某种行为的对象,Java 8有了Lambda表达式和方法引用(因为Lambda表达式和方法引用都是直接表述一种行为)后,传递行为的方式更加直观。
2016-07-17 22:10:36
-
Lambda表达式引用的是值,而不是变量。 如果Lambda表达式引用表达式外部的变量,那这个变量只能是一个既成事实上的final变量。 String name = getUserName(); name = formatUserName(name); button.addActionListener(event -> System.out.println("hi " + name)); 以上代码无法通过编译,name可以不用final声明,但是必须和final一样,只能被赋一次值。
2016-07-17 22:24:28
-
例 2-10 使用菱形操作符,根据方法签名做推断 userHashmap(new HashMap<>()); ... private void userHashmap(Map<String, String> values); Java 8中对类型推断系统的改善值得一提。上面的例子将new HashMap<>()传给userHashmap方法,即使编译器拥有足够的信息,也无法在Java 7中通过编译。 例 2-12 Predicate接口的源码,接受一个对象,返回一个布尔值 public interface Predicate<T> { boolean test(...
2016-07-18 08:12:48
例 2-10 使用菱形操作符,根据方法签名做推断
userHashmap(new HashMap<>()); ... private void userHashmap(Map<String, String> values);
Java 8中对类型推断系统的改善值得一提。上面的例子将new HashMap<>()传给userHashmap方法,即使编译器拥有足够的信息,也无法在Java 7中通过编译。 引自 2.5 类型推断 例 2-12 Predicate接口的源码,接受一个对象,返回一个布尔值
public interface Predicate<T> { boolean test(T t); }
BinaryOperator接口,需要接受一个泛型,若没有写明泛型,则默认为Object。
@FunctionalInterface public interface BinaryOperator<T> extends BiFunction<T,T,T> { /** * Returns a {@link BinaryOperator} which returns the lesser of two elements * according to the specified {@code Comparator}. * * @param <T> the type of the input arguments of the comparator * @param comparator a {@code Comparator} for comparing the two values * @return a {@code BinaryOperator} which returns the lesser of its operands, * according to the supplied {@code Comparator} * @throws NullPointerException if the argument is null */ public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) { Objects.requireNonNull(comparator); return (a, b) -> comparator.compare(a, b) <= 0 ? a : b; } /** * Returns a {@link BinaryOperator} which returns the greater of two elements * according to the specified {@code Comparator}. * * @param <T> the type of the input arguments of the comparator * @param comparator a {@code Comparator} for comparing the two values * @return a {@code BinaryOperator} which returns the greater of its operands, * according to the supplied {@code Comparator} * @throws NullPointerException if the argument is null */ public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) { Objects.requireNonNull(comparator); return (a, b) -> comparator.compare(a, b) >= 0 ? a : b; } }
回应 2016-07-18 08:12:48
-
曾小展同学 (冲鸭)
1. 方法引用就是类名称 :: 方法,这种方式比lambda更直 2. 流是否有序,取决与集合是否有序以及对流的操作,例如List是有序,Set是无序的,可以使用sort等方式对流进行排序。 3. 收集器:将收集器传给collect(),就可以生成其他流,比如 (1) 转换为自己想要的集合,使用toCollection(TreeSet::new) (2) 生成一个值:maxBy 和 minBy ,averagingInt 等 (3) 数据分块和分组:partitioningBy 和 groupingby (4) 字符串:joining 连...2020-05-28 13:38:13
1. 方法引用就是类名称 :: 方法,这种方式比lambda更直
2. 流是否有序,取决与集合是否有序以及对流的操作,例如List是有序,Set是无序的,可以使用sort等方式对流进行排序。
3. 收集器:将收集器传给collect(),就可以生成其他流,比如
(1) 转换为自己想要的集合,使用toCollection(TreeSet::new)
(2) 生成一个值:maxBy 和 minBy ,averagingInt 等
(3) 数据分块和分组:partitioningBy 和 groupingby
(4) 字符串:joining 连接
4. 组合收集器的意思是告诉收集器,你用另外一个收集器收集结果。例如list.collect(groupingBy(funciton , counting)),常用的有counting、mapping
5. 重构和定制收集器,通过实现Collector接口来实现,例如,需要一个新的收集器来输出字符串,而不是joining,有一点类似hadoop里面写mapreduce,定义好输入和输出,同时定义好收集器,针对收集器实现对应的supplier、accumulator、combiner、finisher,以及characterstist接口
回应 2020-05-28 13:38:13 -
Strangeen (很懒,什么都没留下)
1. 只用reduce 和Lambda 表达式写出实现Stream 上的map 操作的代码,如果不想返回Stream,可以返回一个List。 2. 只用reduce 和Lambda 表达式写出实现Stream 上的filter 操作的代码,如果不想返回Stream,可以返回一个List。 答案见:[http://www.jianshu.com/p/bec12aa21fc6]2017-11-04 00:28:25
1. 只用reduce 和Lambda 表达式写出实现Stream 上的map 操作的代码,如果不想返回Stream,可以返回一个List。 2. 只用reduce 和Lambda 表达式写出实现Stream 上的filter 操作的代码,如果不想返回Stream,可以返回一个List。 引自 3.10进阶练习 答案见:http://www.jianshu.com/p/bec12aa21fc6
回应 2017-11-04 00:28:25 -
2. 例6-11中的代码把列表中的数字相乘,然后再将所得结果乘以5。顺序执行这段程序没有问题,但并行执行时有一个缺陷,使用流并行化执行该段代码,并修复缺陷。 例6-11 把列表中的数字相乘,然后再将所得结果乘以5,该实现有一个缺陷 // 串行reduce初始值为任意值并不会有问题 public static int multiplyThrough(List<Integer> linkedListOfNumbers) { return linkedListOfNumbers.stream().reduce(5, (acc, x) -> x *...
2016-07-27 08:46:03
2. 例6-11中的代码把列表中的数字相乘,然后再将所得结果乘以5。顺序执行这段程序没有问题,但并行执行时有一个缺陷,使用流并行化执行该段代码,并修复缺陷。 例6-11 把列表中的数字相乘,然后再将所得结果乘以5,该实现有一个缺陷
// 串行reduce初始值为任意值并不会有问题 public static int multiplyThrough(List<Integer> linkedListOfNumbers) { return linkedListOfNumbers.stream().reduce(5, (acc, x) -> x * acc); }
@Test public void test6_9_2() { List<Integer> linkedListOfNumbers = Arrays.asList(1, 2, 3, 4, 5); System.out.println("multiplyThrough: " + multiplyThrough(linkedListOfNumbers)); System.out.println("serialMultiplyThrough: " + serialMultiplyThrough(linkedListOfNumbers)); } // 并行reduce初始值必须为特定值,所以为了保持结果不变,把最终结果 * 5 public static int serialMultiplyThrough(List<Integer> linkedListOfNumbers) { return 5 * linkedListOfNumbers.parallelStream().reduce(1, (acc, x) -> x * acc); }
3.例6-12中的代码计算列表中数字的平方和。尝试改进代码性能,但不得牺牲代码质量。只需要一些简单的改动即可。 例6-12 求列表元素的平方和,该实现方式性能不高
public int solwSumOfSquares(List<Integer> linkedListOfNumbers) { return linkedListOfNumbers.parallelStream().map(x -> x * x) .reduce(0, (acc, x) -> acc + x); }
@Test public void test6_9_3() { List<Integer> linkedListOfNumbers = Arrays.asList(1, 2, 3, 4, 5); System.out.println("solwSumOfSquares: " + solwSumOfSquares(linkedListOfNumbers)); System.out.println("fastSumOfSquares: " + fastSumOfSquares(linkedListOfNumbers)); System.out.println("serialFastSumOfSquares: " + serialFastSumOfSquares(linkedListOfNumbers)); } // 高效并行计算 public int fastSumOfSquares(List<Integer> linkedListOfNumbers) { return linkedListOfNumbers.parallelStream().mapToInt(x -> x * x).sum(); } // 高效串行计算 public int serialFastSumOfSquares(List<Integer> linkedListOfNumbers) { return linkedListOfNumbers.stream().mapToInt(x -> x * x).sum(); }
回应 2016-07-27 08:46:03
当前版本有售 · · · · · ·
-
每满100-50
以下书单推荐 · · · · · · ( 全部 )
- 北京地铁书单(豆列) (向北向北)
- T (dhcn)
- 3.Java想研究的书 (葡萄)
- 3.java函数式编程 (葡萄)
- cathay书单 (葡萄)
谁读这本书?
二手市场
订阅关于Java 8函数式编程的评论:
feed: rss 2.0
0 有用 Ben 2016-05-02 16:44:56
特别惊诧于Java中引入函数式编程的方法,这么天然无邪,和原有的API又整合得毫无痕迹
0 有用 void 2016-11-27 14:57:41
随便看看,没啥用
0 有用 hoterran 2018-07-27 16:32:40
不咋地,很多内容是别的书有的。
0 有用 天平上的尘埃 2017-08-25 14:41:48
翻译的确实有些差强人意,但总体来说还是快速全面的介绍了Java8里新增lambda特性的方方面面
0 有用 李鼎 2016-05-05 01:03:42
Java 8的函数式用法的入门佳作,非常薄148面,简直不敢相信这么小的篇幅讲了这么多内容。第9章讲并发程序编写,只短短10来面就广度了不少内容,几个关键点及其关联异同的讲解闪烁着思辨的光辉,很是精彩! 🌈
0 有用 一条咸鱼 2022-04-19 01:39:10
对lambda的介绍还算详细,如果对java8的lambda感兴趣值得一读。
0 有用 吴焚舟 2022-01-16 11:24:14
讲得还是比较透彻的。 Stream和Optional真的是梦回Scala。。。虽然好吧我知道Java 8也不新了 还有那个interface的default,整个一个有点震惊 也(只有一点点)开始考虑编程语言的演进和选择了,毕竟在Java原有基础上改成这样真的是。。。有点丑啊。。。
0 有用 YeungYeah 2021-09-25 22:44:07
介绍了 java8 中出现的 Lambda 函数以及相应的流式编程,非常对喜爱函数式编程的 Java 程序员胃口
0 有用 迷糊蛋儿 2021-09-01 11:56:06
小巧易读 阐述背后的思想 推荐阅读的文章和书
0 有用 未完成交响曲 2021-07-05 22:45:21
薄薄一本书,内容不多,大部分api平时都用过,没用过的估计也用不上了