Java 实战

[Java 实战(第 2 版)] [Modern Java in Action]

【第一部分 基础知识】

第 1 章 Java 8、9、10 以及 11 的变化

第 2 章 通过行为参数化传递代码

第 3 章 Lambda 表达式

【第二部分 使用流进行函数式数据处理】

第 4 章 引入流

第 5 章 使用流

第 6 章 用流收集数据

第 7 章 并行数据处理与性能

【第三部分 使用流和 Lambda 进行高效编程】

第 8 章 Collection API 的增强功能

第 9 章 重构、测试和调试

第 10 章 基于 Lambda 的领域特定语言

【第四部分 无所不在的 Java】

第 11 章 用 Optional 取代 null

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Person {
    private Car car;

    public Car getCar() {
        return car;
    }
}

class Car {
    private Insurance insurance;

    public Insurance getInsurance() {
        return insurance;
    }
}

class Insurance {
    private String name;

    public String getName() {
        return name;
    }
}
1
2
3
public String getCarInsuranceName(Person person) {
    return person.getCar().getInsurance().getName();
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public String getCarInsuranceNameV1(Person person) {
    if (person != null) {
        Car car = person.getCar();
        if (car != null) {
            Insurance insurance = car.getInsurance();
            if (insurance != null) {
                return insurance.getName();
            }
        }
    }
    return "Unknow";
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
public String getCarInsuranceNameV2(Person person) {
    if (person == null) {
        return "Unknow";
    }
    Car car = person.getCar();
    if (car == null) {
        return "Unknow";
    }
    Insurance insurance = car.getInsurance();
    if (insurance == null) {
        return "Unknow";
    }
    return insurance.getName();
}

第 12 章 新的日期和时间 API

第 13 章 默认方法

第 14 章 Java 模块系统

【第五部分 提升 Java 的并发性】

第 15 章 CompletableFuture 及反应式编程背后的概念

第 16 章 CompletableFuture:组合式异步编程

第 17 章 反应式编程

【第六部分 函数式编程以及 Java 未来的演进】

第 18 章 函数式的思考

第 19 章 函数式编程的技巧

第 20 章 面向对象和函数式编程的混合:Java 和 Scala 的比较

第 21 章 结论以及 Java 的未来