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

作者: [英] Richard Warburton
出版社: 人民邮电出版社
译者: 王群锋
出版年: 2015-3
页数: 148
定价: 39.00元
装帧: 平装
ISBN: 9787115384881

豆瓣评分

7.8

169人评价

5星

30.8%
4星

47.3%
3星

20.7%
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
· · · · · · (更多)

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

Java 函数式编程 Java8 编程计算机函数 java 软件开发

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

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

: Scala与Clojure函数式编程模式

24.99元

: 七周七并发模型

24.99元

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

24.99元

: Maven实战

17.99元

: Java虚拟机精讲

27.60元

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

: Java程序员修炼之道

: Java并发编程实战

: Java性能权威指南

: Java 8实战

: Scala程序设计（第2版）

: Spring实战（第4版）

: NoSQL精粹

: Effective java 中文版（第2版）

: 从Paxos到Zookeeper

: 软件设计重构

我来说两句

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

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

什么是话题

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

我要写书评

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

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

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

0回应

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

初步了解Java8中的lambda编程

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

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

2回应

> 更多书评2篇

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

我来写笔记

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

展开收起
第33页

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。
答案见：http://www.jianshu.com/p/bec12aa21fc6

推荐

回应 2017-11-04 00:28
展开收起
第90页

nico

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

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

推荐

回应 2016-07-27 21:04

展开 收起
第80页

nico

2. 例6-11中的代码把列表中的数字相乘，然后再将所得结果乘以5。顺序执行这段程序没有问题，但并行执行时有一个缺陷，使用流并行化执行该段代码，并修复缺陷。例6-11 把列表中的数字相乘，然后再将所得结果乘以5，该实现有一个缺陷 /代码内容已省略/ /代码内容已省略/ 3.例6-12中的代码计算列表中数字的平方和。尝试改进代码性能，但不得牺牲代码质...

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

展开收起
第78页
nico
数组上的并行化操作 1. parallelPrefix 任意给定一个函数，计算数组的和 2. parallelSetAll 使用Lambda表达式更新数组元素 3. parallelSort 并行化对数组元素排序例6-8 使用并行化数组操作初始化数组 /代码内容已省略/
2016-07-27 08:18
数组上的并行化操作
1. parallelPrefix 任意给定一个函数，计算数组的和 2. parallelSetAll 使用Lambda表达式更新数组元素 3. parallelSort 并行化对数组元素排序
例6-8 使用并行化数组操作初始化数组
@Test public void test6_8() { double[] values = parallelInitialize(10); Arrays.stream(values).forEach(System.out::println); } public static double[] parallelInitialize(int size) { double[] values = new double[size]; Arrays.parallelSetAll(values, i -> i + 0.1); return values; }

推荐

回应 2016-07-27 08:18

展开收起
第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页
nico
Lambda表达式引用的是值，而不是变量。如果Lambda表达式引用表达式外部的变量，那这个变量只能是一个既成事实上的final变量。 /代码内容已省略/ 以上代码无法通过编译，name可以不用final声明，但是必须和final一样，只能被赋一次值。
2016-07-17 22:24
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
展开收起
第9页

nico

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

函数接口是只有一个抽象方法的接口，用作Lambda表达式的类型。

这就是函数接口，接口中单一方法的命名并不重要，只要方法签名和Lambda表达式的类型匹配即可。

推荐

回应 2016-07-18 08:01

展开 收起
第10页

nico

例 2-10 使用菱形操作符，根据方法签名做推断 /代码内容已省略/ Java 8中对类型推断系统的改善值得一提。上面的例子将new HashMap<>()传给userHashmap方法，即使编译器拥有足够的信息，也无法在Java 7中通过编译。例 2-12 Predicate接口的源码，接受一个对象，返回一个布尔值 /代码内容已省略/ BinaryOperator接口，需要接受一个泛型，若..

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-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

展开收起
第33页

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。
答案见：http://www.jianshu.com/p/bec12aa21fc6

推荐

回应 2017-11-04 00:28
展开收起
第90页

nico

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

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

推荐

回应 2016-07-27 21:04

展开 收起
第80页

nico

2016-07-27 08:46

例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

展开收起
第78页
nico
数组上的并行化操作 1. parallelPrefix 任意给定一个函数，计算数组的和 2. parallelSetAll 使用Lambda表达式更新数组元素 3. parallelSort 并行化对数组元素排序例6-8 使用并行化数组操作初始化数组 /代码内容已省略/
2016-07-27 08:18
数组上的并行化操作
1. parallelPrefix 任意给定一个函数，计算数组的和 2. parallelSetAll 使用Lambda表达式更新数组元素 3. parallelSort 并行化对数组元素排序
例6-8 使用并行化数组操作初始化数组
@Test public void test6_8() { double[] values = parallelInitialize(10); Arrays.stream(values).forEach(System.out::println); } public static double[] parallelInitialize(int size) { double[] values = new double[size]; Arrays.parallelSetAll(values, i -> i + 0.1); return values; }

推荐

回应 2016-07-27 08:18