Name: Java 8函数式编程
ISBN: 9787115384881

作者: [英] Richard Warburton
出版社: 人民邮电出版社
译者: 王群锋
出版年: 2015-3
页数: 148
定价: 39.00元
装帧: 平装
丛书: 图灵程序设计丛书·Java系列
ISBN: 9787115384881

豆瓣评分

7.8

258人评价

5星

28.3%
4星

50.8%
3星

19.8%
2星

1.2%
1星

0.0%

评价:

内容简介 · · · · · ·

通过每一章的练习快速掌握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西安研发中心，从事下一代统计预测软件的开发运维工作。

目录 · · · · · ·

前言　　IX
第1章　简介　　1
1.1　为什么需要再次修改Java　　1
1.2　什么是函数式编程　　2
1.3　示例　　2
第2章　Lambda 表达式　　5
· · · · · · (更多)

"Java 8函数式编程"试读 · · · · · ·

O’Reilly Media 通过图书、杂志、在线服务、调查研究和会议等方式传播创新知识。自1978 年开始，O’Reilly 一直都是前沿发展的见证者和推动者。超级极客们正在开创着未来，而我们关注真正重要的技术趋势——通过放大那些“细微的信号”来刺激社会对新科技的应用。作为技术社区中活跃的参与者，O’Reilly 的发展充满了对创新的倡导、创造和发扬光大。 O’Reilly 为软件开发人员带来革命..

· · · · · · (查看全部试读)

原文摘录 · · · · · · ( 全部 )

面向对象编程是对数据进行抽象，而函数式编程是对行为进行抽象。 (查看原文)

nico 2016-07-17 22:10:36

—— 引自第1页
Lambda表达式引用的是值，而不是变量。 (查看原文)

nico 2016-07-17 22:24:28

—— 引自第8页

> 全部原文摘录

豆瓣成员常用的标签(共47个) · · · · · ·

Java 函数式编程编程计算机软件开发 java Programming 技术

丛书信息

　　图灵程序设计丛书·Java系列 (共55册), 这套丛书还有《Java解惑》,《Java性能权威指南》,《Java轻松学》,《JSF实战》,《JRuby实战》等。

喜欢读"Java 8函数式编程"的人也喜欢的电子书 · · · · · ·

支持 Web、iPhone、iPad、Android 阅读器

: 深入理解Java虚拟机：JVM高级特性与最佳实践

25.00元

: Redis开发与运维

15.00元

: Python源码剖析

17.99元

: 白帽子讲Web安全

17.25元

: 淘宝技术这十年

4.99元

喜欢读"Java 8函数式编程"的人也喜欢 · · · · · ·

: Scala程序设计（第2版）

: Akka应用模式：分布式应用程序设...

: 快学Scala（第2版）

: Akka入门与实践

: Netty实战

: Java程序员修炼之道

: 实战Java虚拟机

: 七周七并发模型

: Effective java 中文版（第2版）

: 函数式编程思维

我来说两句

短评 · · · · · · ( 全部 116 条 )

Java 8函数式编程的话题 · · · · · · ( 全部条 )

什么是话题

无论是一部作品、一个人，还是一件事，都往往可以衍生出许多不同的话题。将这些话题细分出来，分别进行讨论，会有更多收获。

我要写书评

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

热门 / 最新 / 好友 /只看本版本的评论

ginobefun 2016-12-14 15:39:31

入门Java 8核心特性的最佳读物

这本书在很短的篇幅内详细地讲解了Java 8函数式的核心特性，并附以实际的例子加深理解。特别是关于收集器那一章节，把我之前的疑问完全解开。非常值得一读的书，五星好评！附上我的个人读书笔记：《Java 8函数式编程》读书笔记 (展开)

0回应

陪孩子看剧中 2020-11-24 08:06:58

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

一直是java 所以这方面的书看了很多，因为工作方向的更改已经很久没看过java相关的书了，偶尔想在拿起来看看回忆巩固一下，所谓技多不压身，踏实！这本书我一直比较喜欢，因为短小精悍，知识点都讲到了也都讲的比较明了不像现在有的书远远望去真的就是一块板砖啊为了凑字... (展开)

0回应

望断缥缈 2020-01-23 18:09:03

《java 8函数式编程》笔记

这篇书评可能有关键情节透露

#lambda lambda将行为像数据一样传递。影响性能五个要素：数据大小，源数据结构，值是否装箱，可用的cpu数量，处理每个元素花的时间。测试lambda需要将重点放在行为上。 lambda单元测试：抽取成为一个具名方法。 peek可以记录中间值，利于调试。 #设计模式命令者模式使用对... (展开)

0回应

奔月 2015-06-10 19:54:04

初步了解Java8中的lambda编程

这篇书评可能有关键情节透露

本书虽然是讲Java8中的lambda表达式，但是书中并没有详细的介绍有关lambda表达式的知识，读者最好学习过lambda的相关知识，至少要知道什么是lambda表达式。 java8中引入了lambda表达式，使java有了函数式编程的语法特征。相较于java6，7并没有对类库有较大的更改，... (展开)

2回应

> 更多书评 4篇

读书笔记 · · · · · · (共36篇)

我来写笔记

按有用程度
按页码先后
最新笔记

展开收起
第5章

曾小展同学 (冲鸭)

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

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
展开收起
第33页 3.10进阶练习

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

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
展开收起
第90页 7 测试

nico

1. 重构遗留代码时考虑如何使用Lambda表达式，有一些通用的模式。 2. 如果想要对复杂一点的Lambda表达式编写单元测试，将其抽取成一个常规的方法。 3. peek方法能记录中间值，在调试时非常有用。
2016-07-27 21:04

1. 重构遗留代码时考虑如何使用Lambda表达式，有一些通用的模式。 2. 如果想要对复杂一点的Lambda表达式编写单元测试，将其抽取成一个常规的方法。 3. peek方法能记录中间值，在调试时非常有用。
引自 7 测试

推荐

回应 2016-07-27 21:04

展开 收起
第80页 6.9 练习

nico

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

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

展开收起
第1页简介

nico

Q: 为什么要会有Java 8？ A: 适应现代多核CPU，让代码在多核CPU上高效运行。面向对象编程是对数据进行抽象，而函数式编程是对行为进行抽象。以前传递行为的方式是传递拥有具有某种行为的对象，Java 8有了Lambda表达式和方法引用（因为Lambda表达式和方法引用都是直接表述一种行为）后，传递行为的方式更加直观。
2016-07-17 22:10

Q: 为什么要会有Java 8？ A: 适应现代多核CPU，让代码在多核CPU上高效运行。
面向对象编程是对数据进行抽象，而函数式编程是对行为进行抽象。
引自简介
以前传递行为的方式是传递拥有具有某种行为的对象，Java 8有了Lambda表达式和方法引用（因为Lambda表达式和方法引用都是直接表述一种行为）后，传递行为的方式更加直观。

推荐

回应 2016-07-17 22:10
展开收起
第8页 2.3 引用值，而不是变量
nico
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
Lambda表达式引用的是值，而不是变量。
引自 2.3 引用值，而不是变量
如果Lambda表达式引用表达式外部的变量，那这个变量只能是一个既成事实上的final变量。
String name = getUserName(); name = formatUserName(name); button.addActionListener(event -> System.out.println("hi " + name));
以上代码无法通过编译，name可以不用final声明，但是必须和final一样，只能被赋一次值。

推荐

回应 2016-07-17 22:24
展开收起
第9页 2.4 函数接口

nico

函数接口是只有一个抽象方法的接口，用作Lambda表达式的类型。这就是函数接口，接口中单一方法的命名并不重要，只要方法签名和Lambda表达式的类型匹配即可。
2016-07-18 08:01

函数接口是只有一个抽象方法的接口，用作Lambda表达式的类型。这就是函数接口，接口中单一方法的命名并不重要，只要方法签名和Lambda表达式的类型匹配即可。
引自 2.4 函数接口

推荐

回应 2016-07-18 08:01

展开 收起
第10页 2.5 类型推断

nico

例 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

例 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

展开收起
第5章

曾小展同学 (冲鸭)

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

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
展开收起
第33页 3.10进阶练习

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

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
展开收起
第90页 7 测试

nico

1. 重构遗留代码时考虑如何使用Lambda表达式，有一些通用的模式。 2. 如果想要对复杂一点的Lambda表达式编写单元测试，将其抽取成一个常规的方法。 3. peek方法能记录中间值，在调试时非常有用。
2016-07-27 21:04

1. 重构遗留代码时考虑如何使用Lambda表达式，有一些通用的模式。 2. 如果想要对复杂一点的Lambda表达式编写单元测试，将其抽取成一个常规的方法。 3. peek方法能记录中间值，在调试时非常有用。
引自 7 测试

推荐

回应 2016-07-27 21:04

展开 收起
第80页 6.9 练习

nico

2016-07-27 08:46

// 串行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);
}

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

> 更多读书笔记（共36篇）

在这本书的论坛里发言