Java8【有与无】【精华篇】实用通识

序：本篇内容较多，排版有些乱，希望大家理解

---

目录

关键词

行为参数化

方法引用

流 Stream/parallelStream【构建器模式】

分支步骤

默认方法

（结构）模式匹配【不完全支持】

行为参数化【工厂模式】

Lambda表达式

收集器【静态工厂 Collectors】【工厂方法】

 并行处理

 分支/合并框架

 重构、测试和调试

默认方法 

Optional 

CompletableFuture 

新的日期和时间API

参考表格

Github

附录

A.术语

1.并发与并行

2.谓词 Predicate

3.外部迭代与内部迭代

4.Collection与Stream

5.匿名类

6.函数描述符

7.装箱与拆箱 boxing and unboxing

8.实例变量、局部变量和类变量

9.闭包

10.堆与栈

11.集合与流

12.map与flatMap

13. findFirst与 findAny

14.collect、reducing、reduce

15.可读性

16.Lambda表达式特点

17.抽象类和抽象接口之间的区别

18.null 引用和 Optional.empty()

19.混聚mash-up

20.并发与并行

21.同步API与异步API

22.调整线程池的大小

23.并行——使用流还是 CompletableFutures

B.优化与拓展

无副作用计算

声明式编程

函数式编程

数学函数

纯粹的函数式编程

引用透明性

尾-调优化（tail-call optimization）Java8 目前不支持

一等函数（first-class function）

科里化

持久化数据结构

Stream延迟计算

模式匹配 Java8 目前不支持

结合器

C.参考代码

1.Collector接口实现

 2.CompletableFuture

3.拓展 

---

关键词

 

行为参数化

把方法（你的代码）作为参数传递给另一个方法的能力

 

方法引用

符号  ‘::’

以(数学)函数作为参数传递给方法，参数可以理解为值

函数：无可变共享状态，可以有效、安全地并行执行

类别：

1.指向静态方法的方法引用

2.指向任 意类型实例方法的方法引用 

3.指向现有对象的实例方法的方法引用

// Lambda表达式的签名与函数描述符兼容
List str = Arrays.asList("a","b","A","B");
str.sort((s1, s2) -> s1.compareToIgnoreCase(s2));
str.sort(String::compareToIgnoreCase);

Function stringToInteger = (String s) -> Integer.parseInt(s);
Function stringToInteger = Integer::parseInt;

BiPredicate, String> contains = (list, element) -> list.contains(element);
BiPredicate, String> contains = List::contains;

// 构造函数引用
// 无参
Supplier c1 = Apple::new;
Apple a1 = c1.get();
// 等价于
Supplier c1 = () -> new Apple();
Apple a1 = c1.get();
// 有参
Function c2 = Apple::new;
Apple a2 = c2.apply(110);
// 等价于
Function c2 = (weight) -> new Apple(weight);
Apple a2 = c2.apply(110);

 

流 Stream/parallelStream【构建器模式】

比喻：车间流水线式工作

特点：透明地并行处理，高级迭代器

定义：从支持数据处理操作的源生成的元素序列

操作：中间操作｛连接起来的流操作｝    终端操作｛关闭流的操作｝

应用场景：IO密集，CPU密集

对比：

java.util.stream.Stream 串行执行

java.util.Collection.parallelStream  多核架构并行执行 【ForkJoinPool】【慎用】

函数：

1.reduce 根据一定的规则将Stream中的元素进行计算后返回一个唯一的值。

考虑使用parallelStream
1.是否需要并行？  
2.任务之间是否是独立的？是否会引起任何竞态条件？  
3.结果是否取决于任务的调用顺序？

Stream API带来的代码特性
1.声明性——更简洁，更易读
2.可复合——更灵活
3.可并行——性能更好

使用流
1.一个数据源（如集合）来执行一个查询
2.一个中间操作链，形成一条流的流水线
3.一个终端操作，执行流水线，并能生成结果

// 举例
long count = list.stream()
                 .filter(d -> d.getCalories() > 300)
                 .distinct()
                 .limit(3)
                 .count();

List names = list.stream()
                         .filter(d -> d.getCalories() > 300)
                         .map(Dish::getName)
                         .limit(3)
                         .collect(toList());

// 归约：归类、折叠（folk）, 反复迭代
// 有初始值                     初始值,BinaryOperator
int sum = numbers.stream().reduce(0, (a, b) -> a + b);
// 无初始值                                      BinaryOperator
Optional sum = numbers.stream().reduce((a, b) -> (a + b));

// 数值流
// IntStream、DoubleStream、LongStream，分别将流中的元素特化为 int、long、double， 避免了暗含的装箱成本

// 映射到数值流
//  mapToInt、mapToDouble、mapToLong
IntStream intStream = intList.stream().mapToInt(Dish::getValue);

// 转换回对象流
Stream stream = intStream.boxed();

// 默认值
// Optional 原始类型特化版本： OptionalInt、OptionalDouble、OptionalLong


// 数值范围
// Java 8引入了两个可以用于 IntStream 和 LongStream 的静态方法
IntStream evenNumbers = IntStream.rangeClosed(1, 100).filter(n -> n % 2 == 0);

// 由值创建流
Stream stream = Stream.of("Java 8 ", "Lambdas ", "In ", "Action");
Stream emptyStream = Stream.empty();

// 由数组创建流
int[] numbers = {2, 3, 5, 7, 11, 13};
int sum = Arrays.stream(numbers).sum();

// 由文件生成流
long uniqueWords = 0;
try(Stream lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())){
    uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" ")))
                       .distinct()
                       .count();
}
catch(IOException e){
}

// 由函数生成流：创建无限流
// Stream API提供了两个静态方法来从函数生成流： Stream.iterate 和 Stream.generate
// 迭代
Stream.iterate(0, n -> n + 2)
      .limit(10)
      .forEach(System.out::println);
// 生成
Stream.generate(Math::random)
      .limit(5)
      .forEach(System.out::println);

分支步骤

完成一个任务，将其分解成若干个任务，并行处理，然后合并，最终将任务完成

 

默认方法

符号 ‘default’

扩充现有接口，不影响实现类的代码；

在接口中提供默认的实现方法

 

（结构）模式匹配【不完全支持】

f(0) = 1
f(n) = n*f(n-1) otherwise

 

行为参数化【工厂模式】

应对频繁变更的需求，灵活，简洁

让方法接受多种行为（或战略）作为参数，并在内部使用，来完成不同的行为

是类、匿名类、Lambda的集合体

 

Lambda表达式

可以理解成是一种匿名类，或是一种接口的实现类

代码更加简洁

一种编程风格

① 用处：

1.函数式接口

只定义一个抽象方法的接口，用来传递行为

接口设计 @FunctionalInterface

1.1.Predicate【谓语】【测试者】

java.util.function.Predicate 接口定义了一个名叫 test 的抽象方法，它接受泛型 T 对象，并返回一个 boolean 。

@FunctionalInterface
public interface Predicate{
    boolean test(T t);
}
public static  List filter(List list, Predicate p) {
    List results = new ArrayList<>();
    for(T s: list){
        if(p.test(s)){
            results.add(s);
        }
    }
    return results;
}
Predicate nonEmptyStringPredicate = (String s) -> !s.isEmpty();
List nonEmpty = filter(listOfStrings, nonEmptyStringPredicate);

1.2.Consumer【消费者】

java.util.function.Consumer 定义了一个名叫 accept 的抽象方法，它接受泛型 T 的对象，没有返回（ void ）。你如果需要访问类型 T 的对象，并对其执行某些操作，就可以使用这个接口。T 只能是引用类型。

@FunctionalInterface
public interface Consumer{
    void accept(T t);
}
public static  void forEach(List list, Consumer c){
    for(T i: list){
        c.accept(i);
    }
}

forEach(Arrays.asList(1,2,3,4,5), (Integer i) -> System.out.println(i));

1.3.Function【功能】【类型转换】

java.util.function.Function 接口定义了一个叫作 apply 的方法，它接受一个泛型 T 的对象，并返回一个泛型 R 的对象。

@FunctionalInterface
public interface Function{
    R apply(T t);
}
public static  List map(List list, Function f) {
    List result = new ArrayList<>();
    for(T s: list){
        result.add(f.apply(s));
    }
    return result;
}

// [7, 2, 6]
List l = map(Arrays.asList("lambdas","in","action"), (String s) -> s.length());

1.4.Supplier【生产者】

java.util.function.Supplier接口接口定义了一个叫作 get 的方法,它接受一个泛型 T 的对象,并返回一个泛型 T 的对象。

@FunctionalInterface
public interface Supplier {
    T get();
}

Supplier supplier = String::new;

② 类型检查过程

1.确定目标函数类型

2.执行目标函数

③ 限制条件

1.局部变量必须显式声明为 final，保存在栈上。（产生原因是多线程，本质原因是存储的位置不同）

 

收集器【静态工厂 Collectors】【工厂方法】

功能：

1.将流元素归约和汇总为一个值

2.元素分组

3.元素分区

/** 一下是Collectors.reducing 工厂方法提供的广义归约收集器的特殊情况 **/

// 归约collect,计算总数
long howManyDishes = menu.stream().collect(Collectors.counting());
long howManyDishes = menu.stream().count();

// 查找流中的最大值和最小值
Comparator dishValuesComparator = Comparator.comparingInt(Dish::getValues);
Optional mostValuesDishMax = 
    menu.stream().collect(Collectors.maxBy(dishCaloriesComparator));
Optional mostValueDishMin = 
    menu.stream().collect(Collectors.minBy(dishCaloriesComparator));

// 汇总
int totalValues = 
  menu.stream().collect(Collectors.summingInt(Dish::getValues));
double totalValues = 
  menu.stream().collect(Collectors.summingDouble(Dish::getValues));
long totalValues =
  menu.stream().collect(Collectors.summingLong(Dish::getValues));

// 计算数值的平均数
int avgValues = 
  menu.stream().collect(Collectors.averagingInt(Dish::getValues));
double avgValues = 
  menu.stream().collect(Collectors.averagingDouble(Dish::getValues));
long avgValues = 
  menu.stream().collect(Collectors.averagingLong(Dish::getValues));

// 利用summarizingInt工厂方法返回的收集器，一次性获取总和、平均值、最大值和最小值
IntSummaryStatistics statistics = 
  menu.stream().collect(Collectors.summarizingInt(Dish::getValues));
DoubleSummaryStatistics statistics = 
  menu.stream().collect(Collectors.summarizingDouble(Dish::getValues));
LongSummaryStatistics statistics = 
  menu.stream().collect(Collectors.summarizingLong(Dish::getValues));

// 连接字符串，内部使用了StringBuilder
String shortMenu = menu.stream().map(Dish::getName).collect(joining());
String shortMenu = menu.stream().map(Dish::getName).collect(joining(", "));

// 一般通用的归约， 要用Collectors.reducing工厂方法进行归约
int totalCalories = menu.stream().collect(reducing(0, Dish::getCalories, (i, j) -> i + j));

// stream->collect->reducing->用法介绍,用于可变的归约,适合并行操作
// reducing收集器永远都不会返回 Optional.empty() 

// 无初始值的情况，返回一个可以生成Optional结果的Collector
// 参数：op是核心函数，作用是如何处理两个变量。
//          第一个变量是累积值，可以理解为sum，第二个变量则是下一个要计算的元素。
// 类型：T是Stream里的元素类型
// public static  Collector>reducing(BinaryOperator op)

Comparator byHeight = Comparator.comparing(Person::getHeight);
Map> tallestByCity = personList.stream().collect(
  groupingBy(
    Person::getCity, reducing(BinaryOperator.maxBy(byHeight))
  )
);
tallestByCity.forEach(
  (k,v)->
    System.out.println(
      JSONObject.fromObject(k) + "=" + JSONObject.fromObject(v.get())
    )
);

// 有初始值的情况，返回一个可以直接产生结果的Collector
// 参数：identity[返回类型的初始值]
//      op是核心函数，作用是如何处理两个变量。
//        第一个变量是累积值，可以理解为sum，第二个变量则是下一个要计算的元素。
// 类型：T是Stream里的元素类型
// public static  Collector>reducing(T identity,BinaryOperator op

Map tallestByCity1 = personList.stream().collect(
  groupingBy(Person::getCity, reducing(new Person(), BinaryOperator.maxBy(byHeight)))
);
tallestByCity1.forEach((k,v)->
  System.out.println(JSONObject.fromObject(k) + "=" + JSONObject.fromObject(v)));

// 有初始值，还有针对元素的处理方案mapper，生成一个可以直接产生结果的Collector，
// 元素在执行结果操作op之前需要先执行mapper进行元素转换操作
// 参数：
//      identity[返回类型的初始值]
//      mapper则是map的作用，意义在于将Stream流转换成你想要的类型流
//      op是核心函数，作用是如何处理两个变量。
//        第一个变量是累积值，可以理解为sum，第二个变量则是下一个要计算的元素。
// 类型：U 返回类型；T是Stream里的元素类型；
// public static Collector reducing(U identity,
// Function mapper,BinaryOperator op)

Comparator byLength = Comparator.comparing(String::length);
Map longestNameByCity = personList.stream().collect(
  groupingBy(
    Person::getCity, reducing("", Person::getLastName, BinaryOperator.maxBy(byLength))
  )
);
longestNameByCity.forEach((k,v)->
  System.out.println(JSONObject.fromObject(k)  + "=" + v));

// 有初始值，迭代计算，返回结果值
// 参数：
//   identity[返回类型的初始值]
//   accumulator[迭代计算] 
// 类型：T是Stream里的元素类型
// T reduce(T identity, BinaryOperator accumulator)

Integer sums = Stream.of(1, 2, 3, 4).reduce(0, (sum, item) -> sum + item);
        System.out.println(sums);

 

// 分组，groupingBy，桶
Map> dishesByType = menu.stream().collect(groupingBy(Dish::getType));
// 结果
// {FISH=[prawns, salmon], OTHER=[french fries, rice, season fruit, pizza],
// MEAT=[pork, beef, chicken]}

public enum CaloricLevel { DIET, NORMAL, FAT }
Map> dishesByCaloricLevel = menu.stream().collect(
    groupingBy(dish -> {
        if (dish.getCalories() <= 400) return CaloricLevel.DIET;
        else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
        else return CaloricLevel.FAT;
    } )
);

// 多级分组
Map>> dishesByTypeCaloricLevel =
    menu.stream().collect(
        groupingBy(Dish::getType, // 一级分组
            groupingBy(dish -> { // 二级分组
                if (dish.getCalories() <= 400) return CaloricLevel.DIET;
                else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
                else return CaloricLevel.FAT;
            })
        )
);
// 结果
// {MEAT={DIET=[chicken], NORMAL=[beef], FAT=[pork]},
// FISH={DIET=[prawns], NORMAL=[salmon]},
// OTHER={DIET=[rice, seasonal fruit], NORMAL=[french fries, pizza]}}

Map typesCount = 
    menu.stream().collect(groupingBy(Dish::getType, counting()));
// 结果
// {MEAT=3, FISH=2, OTHER=4}

// 把收集器的结果转换为另一种类型
Map mostCaloricByType =
    menu.stream().collect(
        groupingBy(
            Dish::getType, 
            collectingAndThen(maxBy(comparingInt(Dish::getCalories)),// 包装后的收集器
            Optional::get // 转换函数，转换包装后的收集器的结果，返回最终的收集器
        )
    )
);
// 结果
// {FISH=salmon, OTHER=pizza, MEAT=pork}

// 联合使用的其他收集器
Map totalCaloriesByType = menu.stream().collect(
  groupingBy(
    Dish::getType, 
    summingInt(Dish::getCalories)
  )
);

Map> caloricLevelsByType = menu.stream().collect(
  groupingBy(
    Dish::getType, 
    mapping(
      dish -> {
        if (dish.getCalories() <= 400) return CaloricLevel.DIET;
        else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
        else return CaloricLevel.FAT; 
      },
      toSet() // 此处可以让你更多控制结果数据
    )
  )
);
// 结果
// {OTHER=[DIET, NORMAL], MEAT=[DIET, NORMAL, FAT], FISH=[DIET, NORMAL]}

// 分区是分组的特殊情况：由一个谓词（返回一个布尔值的函数）作为分类函数，它称分区函数。
// 分区函数返回一个布尔值，得到的分组Map的键类型是Boolean，它最多可以分为true是一组，false是一组。

// 简单分区
Map> partitionedMenu = menu.stream().collect(
    partitioningBy(Dish::isVegetarian) // 分区函数
);
// 结果
// {
//   false=[pork, beef, chicken, prawns, salmon],
//   true=[french fries, rice, season fruit, pizza]
// }

// 分区筛选
List vegetarianDishes = menu.stream().filter(Dish::isVegetarian).collect(toList());
// 等价于
List vegetarianDishes = partitionedMenu.get(true);
// 结果
// [french fries, rice, season fruit, pizza]

// 高级应用
Map>> vegetarianDishesByType = menu.stream().collect(
  partitioningBy(
    Dish::isVegetarian,
    groupingBy(Dish::getType) // 进一步处理
  )
);
// 结果
// {false={FISH=[prawns, salmon], MEAT=[pork, beef, chicken]},
// true={OTHER=[french fries, rice, season fruit, pizza]}}

Map mostCaloricPartitionedByVegetarian = menu.stream().collect(
  partitioningBy(
    Dish::isVegetarian,
    collectingAndThen(
      maxBy(comparingInt(Dish::getCalories)),
      Optional::get
    )
  )
);
// 结果
// {false=pork, true=pizza}

// Collector 接口介绍
public interface Collector {
  Supplier supplier();
  BiConsumer accumulator();
  BinaryOperator combiner();
  Function finisher();
  Set characteristics();
}
// 参数
// T 是流中要收集的项目的泛型
// A 是累加器的类型，累加器是在收集过程中用于累积部分结果的对象
// R 是收集操作得到的对象（通常但并不一定是集合）的类型

// 过程总览
// 1.原始流会以递归方式拆分为子流，直到定义流是否需要进一步拆分的一个条件为非（如果分布式工作单
// 位太小，并行计算往往比顺序计算要慢，而且要是生成的并行任务比处理器内核数多很多的话就没什么用了
// 2.所有的子流都可以进行并行处理，进行归约。
// 3.使用收集器combiner方法返回的函数，将所有的部分结果两两合并。这时会把原始流每次拆分时
// 得到的子流对应的结果合并起来。

// 自定义接口的实现
public class ToListCollector implements Collector, List>

// 详细介绍
// 前四个方法都会返回一个会被 collect 方法调用的函数
// 第五个方法 characteristics 则提供了一系列特征，也就是一个提示列表，告诉 collect 方法在执行归
// 约操作的时候可以应用哪些优化（比如并行化）

// 1.生产者：[建立新的结果容器] supplier()

// supplier 方法必须返回一个结果为空的 Supplier ，也就是一个无参数函数，在调用时它会创建一个空的
// 累加器实例，供数据收集过程使用

// 举例
public Supplier> supplier() {
  return () -> new ArrayList();
}
public Supplier> supplier() {
  return ArrayList::new;
}

// 2.累加器：[将元素添加到结果容器] accumulator()

// accumulator 方法会返回执行归约操作的函数。
// 当遍历到流中第n个元素时，这个函数执行时会有两个参数：
//   保存归约结果的累加器（已收集了流中的前 n1 个项目），还有第n个元素本身。
// 该函数将返回void，因为累加器是原位更新，即函数的执行改变了它的内部状态以体现遍历的元素的效果。

// 举例
public BiConsumer, T> accumulator() {
  return (list, item) -> list.add(item);
}
public BiConsumer, T> accumulator() {
  return List::add;
}

// 3.转换器：[对结果容器应用最终转换] finisher()

// 在遍历完流后，finisher方法必须返回在累积过程的最后要调用的一个函数，以便将累加器对象转换为
// 整个集合操作的最终结果。

// 举例
public Function, List> finisher() {
  return Function.identity();
}

// 4.完成器/组合器：[合并两个结果容器] combiner() [并行时执行]
// 返回一个供归约操作使用的函数，它定义了对流的各个子部分进行并行处理时，各个子部分归约所得的累
// 加器要如何合并。

// 举例
public BinaryOperator> combiner() {
  return (list1, list2) -> {
     list1.addAll(list2);
     return list1; 
  }
}

5.characteristics()
// 返回一个不可变的 Characteristics 集合，它定义了收集器的行为
// 1) UNORDERED: 归约结果不受流中项目的遍历和累积顺序的影响
// 2) CONCURRENT:  accumulator函数可以从多个线程同时调用，且该收集器可以并行归约流。
//                 如果收集器没有标为UNORDERED，那它仅在用于无序数据源时才可以并行归约。
// 3) IDENTITY_FINISH: 完成器方法返回的函数是一个恒等函数，可以跳过。
//                      这种情况下，累加器对象将会直接用作归约过程的最终结果。

public class ToListCollector implements Collector, List> {
    @Override
    public Supplier> supplier() {
       return ArrayList::new;
    }
    @Override
    public BiConsumer, T> accumulator() {
        return List::add;
    }
    @Override
    public Function, List> finisher() {
        return Function.indentity();
    }
    @Override
    public BinaryOperator> combiner() {
        return (list1, list2) -> {
            list1.addAll(list2);
            return list1;
        };
    }
    @Override
    public Set characteristics() {
        return Collections.unmodifiableSet(EnumSet.of(IDENTITY_FINISH, CONCURRENT));
    }
}

// 如果不实现Collector接口
List dishes = menuStream.collect(
    ArrayList::new, // 生产者
    List::add,      // 累加器
    List::addAll    // 完成器/组合器
);
// characteristics是IDENTITY_FINISH。
// 不易读
// 不推荐这种写法
// 自定义收集器，性能一般会有所提升

 并行处理

// 并行数据处理与性能
// 并行流就是一个把内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

// 举例
public static long parallelSum(long n) {
  return Stream.iterate(1L, i -> i + 1)
    .limit(n)
    .parallel() // 将流转换为并行流，之后进行的所有操作都并行执行
    // .sequential() // 将流转换为顺序流，之后进行的所有操作都顺序执行
   .reduce(0L, Long::sum);
}

// 解释
// 并行流内部使用了默认的 ForkJoinPool,它默认的线程数量就是你的处理器数量，这个值是由
// Runtime.getRuntime().available-Processors() 得到的。
// 下面是改变线程池大小,这是一个全局设置,影响代码中所有的并行流,强烈建议你不要修改它。
System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism","12");

// 并行化过程本身需要对流做递归划分，把每个子流的归纳操作分配到不同的线程，然后把这些操作的结果合
// 并成一个值。在多个内核之间移动数据的代价也可能比你想的要大，所以很重要的一点是要保证在内核中并
// 行执行工作的时间并行流比在内核之间传输数据的时间长。
// **很多情况下不可能或不方便并行化**

// 错用并行流而产生错误的首要原因，就是使用的算法改变了某些共享状态
// 举例
public static long sideEffectSum(long n) {
    Accumulator accumulator = new Accumulator();
    LongStream.rangeClosed(1, n).forEach(accumulator::add);
    return accumulator.total;
}
public class Accumulator {
    public long total = 0;
    public void add(long value) {
       total += value; // 错误根源是不是一个原子操作，它会改变多个线程共享的对象的可变状态
    } 
}
public static long sideEffectParallelSum(long n) {
    Accumulator accumulator = new Accumulator();
    LongStream.rangeClosed(1, n).parallel().forEach(accumulator::add);
    return accumulator.total;
}
System.out.println("SideEffect parallel sum done in: " +
    measurePerf(ParallelStreams::sideEffectParallelSum, 10_000_000L) +"msecs" );
// 每次执行的结果都不同

// 影响性能因素
// 1）装箱,大大降低性能
// 2）操作本身在并行流上的性能就比顺序流差:limit和findFirst等依赖于元素顺序的操作,并行代价大。
//    可以调用unordered方法来把有序流变成无序流对无序并行流调用limit可能会比单个有序流更高效。
//    前提是顺序不是主要因素
// 3）虑流的操作流水线的总计算成本,N*Q 是对成本的一个粗略的定性估计。
//    N是要处理的元素的总数，Q是一个元素通过流水线的大致处理成本。
//    Q值较高就意味着使用并行流时性能好的可能性比较大。
// 4）对于较小的数据量，尽量选择顺序流，并行流，并行会造成额外开销。
// 5）考虑流背后的数据结构是否易于分解,易分解的适合并行流。
// 6）流自身的特点，以及流水线中的中间操作修改流的方式，都可能会改变分解过程的性能。
// 7）考虑终端操作中合并步骤的代价是大是小。

 分支/合并框架

// 分支/合并框架， Java 7 引入
// 目的: 以递归方式将可以并行的任务拆分成更小的任务，然后将每个子任务的结果合并起来生成整体结果。
// 原理：实现ExecutorService接口，把子任务分配给线程池（称为 ForkJoinPool）中的工作线程。

// RecursiveTask
// 介绍
// 创建 RecursiveTask 的一个子类,用于将任务提交 ForkJoinPool。
//     R 是并行化任务（以及所有子任务）产生的结果类型。
//     如果任务不返回结果，则是 RecursiveAction 类型（当然它可能会更新其他非局部机构）。
// 定义
// protected abstract R compute();
// 逻辑，分治算法
// if (任务足够小或不可分) {
//   顺序计算该任务
// } else {
//   将任务分成两个子任务
//   递归调用本方法，拆分每个子任务，等待所有子任务完成
//   合并每个子任务的结果
// }

// 注意
// ForkJoinPool一般来说把它实例化一次，然后把实例保存在静态字段中，使之成为单例
// Runtime.availableProcessors 的返回值来决定线程池使用的线程数


// 有效使用它的最佳做法
// 1）对一个任务调用 join 方法会阻塞调用方，直到该任务做出结果。因此，有必要在两个子任务的计算
//    都开始之后再调用它。否则，你得到的版本会比原始的顺序算法更慢更复杂，因为每个子任务都必须
//    等待另一个子任务完成才能启动。
// 2）不应该在 RecursiveTask 内部使用 ForkJoinPool 的 invoke 方法。相反，你应该始终直接调
//    用 compute 或 fork 方法，只有顺序代码才应该用 invoke 来启动并行计算。
// 3）对子任务调用 fork 方法可以把它排进 ForkJoinPool 。同时对左边和右边的子任务调用它似乎很
//    自然，但这样做的效率要比直接对其中一个调用 compute 低。这样做你可以为其中一个子任务重用
//    同一线程，从而避免在线程池中多分配一个任务造成的开销。
// 4）调试使用分支/合并框架的并行计算可能有点棘手。特别是你平常都在你喜欢的IDE里面看栈
//    跟踪（stack trace）来找问题，但放在分支/合并计算上就不行了，因为调用 compute
//    的线程并不是概念上的调用方，后者是调用 fork 的那个。
// 5）和并行流一样，你不应理所当然地认为在多核处理器上使用分支/合并框架就比顺序计算快。
//    一个任务可以分解成多个独立的子任务，才能让性能在并行化时有所提升。
//    所有这些子任务的运行时间都应该比分出新任务所花的时间长；
//    一个惯用方法是把输入/输出放在一个子任务里，计算放在另一个里，这样计算就可以和输入/输出同时
//    进行。
//    此外，在比较同一算法的顺序和并行版本的性能时还有别的因素要考虑。就像任何其他Java代码一样，
//    分支/合并框架需要“预热”或者说要执行几遍才会被JIT编译器优化。这就是为什么在测量性能之前跑几
//    遍程序很重要，测试框架就是这么做的。同时，编译器内置的优化可能会为顺序版本带来一些优势。
//    必须选择一个标准，来决定任务是要进一步拆分还是已小到可以顺序求值。

// 工作窃取（work stealing）
/*
在实际应用中，这意味着这些任务差不多被平均分配到 ForkJoinPool 中的所有线程上。
每个线程都为分配给它的任务保存一个双向链式队列，每完成一个任务，就会从队列头上取出下一个任务开始执行。
基于前面所述的原因，某个线程可能早早完成了分配给它的所有任务，也就是它的队列已经空了，而其他的线程还很忙。
这时，这个线程并没有闲下来，而是随机选了一个别的线程，从队列的尾巴上“偷走”一个任务。
这个过程一直继续下去，直到所有的任务都执行完毕，所有的队列都清空。
这就是为什么要划成许多小任务而不是少数几个大任，这有助于更好地在工作线程之间平衡负载。
一般来说，这种工作窃取算法用于在池中的工作线程之间重新分配和平衡任务
*/

// Spliterator【可分迭代器（splitable iterator）】【java8 接口】
// 一种自动机制来为你拆分流的机制，为了并行执行而设计的。
public interface Spliterator {
    // 按顺序一个一个使用 Spliterator 中的元素，并且如果还有其他元素要遍历就返回 true 
    boolean tryAdvance(Consumer action);
    // 可以把一些元素划出去分给第二个 Spliterator （由该方法返回），让它们两个并行处理。
    Spliterator trySplit();
    // 估计还剩下多少元素要遍历，即使不那么确切，也能快速算出来是一个值有助于让拆分均匀一点。
    long estimateSize();
    // 代表 Spliterator 本身特性集的编码
    int characteristics();
}

 重构、测试和调试

// 重构、测试和调试
// 1.重构
//   重构代码，用Lambda表达式取代匿名类
//   用方法引用重构Lambda表达式
//   用Stream API重构命令式的数据处理

// 匿名类和Lambda表达式中的 this 和 super 的含义是不同的
// 在匿名类中， this 代表的是类自身, 能屏蔽包含类的变量
// 在Lambda中， this 代表的是包含类, 不能屏蔽包含类的变量

// 1）匿名类转Lambda表达式的注意点
interface Task{
    public void execute();
}
public static void doSomething(Runnable r){ r.run(); }
public static void doSomething(Task a){ a.execute(); }

doSomething(new Task() {
    public void execute() {
        System.out.println("Danger danger!!");
    }
});
// 使用显式的类型转换来解决这种模棱两可的情况
doSomething((Task)() -> System.out.println("Danger danger!!"));
doSomething((Runnable)() -> System.out.println("Danger danger!!"));

// 2）Lambda转方法引用的注意点
Map> dishesByCaloricLevel =
    menu.stream().collect(
        groupingBy(
            dish -> {
                if (dish.getCalories() <= 400) return CaloricLevel.DIET;
                else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
                else return CaloricLevel.FAT;
            }
        )
    );
// 方法引用
Map> dishesByCaloricLevel =
    menu.stream().collect(groupingBy(Dish::getCaloricLevel));

public class Dish{
    public CaloricLevel getCaloricLevel(){
        if (this.getCalories() <= 400) return CaloricLevel.DIET;
        else if (this.getCalories() <= 700) return CaloricLevel.NORMAL;
        else return CaloricLevel.FAT;
    }
}
// 尽量考虑使用静态辅助方法，比如 comparing 、 maxBy。
inventory.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));
inventory.sort(comparing(Apple::getWeight));
// 尽量考虑通用的归约操作,比如 sum 、 maximum
int totalCalories = menu.stream().map(Dish::getCalories).reduce(0, (c1, c2) -> c1 + c2);
int totalCalories = menu.stream().collect(summingInt(Dish::getCalories));

// 3）命令式的数据处理转Stream的注意点
// 命令式代码的模式：筛选和抽取
List dishNames = new ArrayList<>();
for(Dish dish: menu){
    if(dish.getCalories() > 300){
        dishNames.add(dish.getName());
    }
}
menu.parallelStream()
    .filter(d -> d.getCalories() > 300)
    .map(Dish::getName)
    .collect(toList());

// 4）增加代码的灵活性
// 4.1）有条件的延迟执行
if (logger.isLoggable(Log.FINER)){
    logger.finer("Problem: " + generateDiagnostic());
}
// 出现的问题
// 日志器的状态（它支持哪些日志等级）通过 isLoggable 方法暴露给了客户端代码。
// 为什么要在每次输出一条日志之前都去查询日志器对象的状态？
public void log(Level level, Supplier msgSupplier)
logger.log(Level.FINER, () -> "Problem: " + generateDiagnostic());

public void log(Level level, Supplier msgSupplier){
    if(logger.isLoggable(level)){
        log(level, msgSupplier.get());
    }
}
// 4.2）环绕执行
String oneLine = processFile((BufferedReader b) -> b.readLine());
String twoLines = processFile((BufferedReader b) -> b.readLine() + b.readLine());

public static String processFile(BufferedReaderProcessor p) throws IOException {
    try(BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
        return p.process(br);
    }
}
public interface BufferedReaderProcessor {
    String process(BufferedReader b) throws IOException;
}

// 5）使用Lambda 重构面向对象的设计模式
// 5.1）策略模式
// 5.2）模板方法
// 5.3）策略模式
// 5.4）观察者模式
// 5.5）责任链模式
// 5.6）工厂模式

默认方法 

// 默认方法
// 类库设计者，以兼容的方式改进API
public interface Sized {
    int size();
    default boolean isEmpty() {
        return size() == 0;
    }
}

// 默认方法的两种用例：可选方法和行为的多继承
//   可选方法
interface Iterator {
    boolean hasNext();
    T next();
    default void remove() {
        throw new UnsupportedOperationException();
    }
}
//   行为的多继承
public interface Moveable {
    int getX();
    int getY();
    void setX(int x);
    void setY(int y);
    default void moveHorizontally(int distance){
        setX(getX() + distance);
    }
    default void moveVertically(int distance){
        setY(getY() + distance);
    }
}

// 组合接口
public class Monster implements Rotatable, Moveable, Resizable {

}

// 关于继承的一些错误观点
// 继承不应该成为你一谈到代码复用就试图倚靠的万精油。
// 声明为 final 的类不能被其他的类继承，避免发生这样的反模式，防止核心代码的功能被污染。


// 解决冲突的规则
/**
如果一个类使用相同的函数签名从多个地方（比如另一个类或接口）继承了方法，通过三条规则可以进行判断。
(1) 类中的方法优先级最高。类或父类中声明的方法的优先级高于任何声明为默认方法的优先级。
(2) 如果无法依据第一条进行判断，那么子接口的优先级更高：函数签名相同时，优先选择拥有最具体实现的
默认方法的接口，即如果 B 继承了 A ，那么 B 就比 A 更加具体。
(3) 最后，如果还是无法判断，继承了多个接口的类必须通过显式覆盖和调用期望的方法，显式地选择使用哪
一个默认方法的实现。
**/

Optional 

// Java语言的架构师Brian Goetz:
//     Optional 的设计初衷仅仅是要支持能返回 Optional 对象的语法

// 用 Optional 取代 null

// null 带来的种种问题
/**
1.它是错误之源
    NullPointerException 是目前Java程序开发中最典型的异常。
2.它会使你的代码膨胀
    它让你的代码充斥着深度嵌套的 null 检查，代码的可读性糟糕透顶。
3.它自身是毫无意义的
    null自身没有任何的语义，尤其是，它代表的是在静态类型语言中以一种错误的方式对缺失变量值的模。
4.它破坏了Java的哲学
    Java一直试图避免让程序员意识到指针的存在，唯一的例外是： null 指针。
5.它在Java的类型系统上开了个口子
    null 并不属于任何类型，这意味着它可以被赋值给任意引用类型的变量。这会导致问题，原因是当这个
变量被传递到系统中的另一个部分后，你将无法获知这个 null 变量最初的赋值到底是什么类型。
**/

// 应用 Optional 的几种模式
// 1.创建 Optional 对象

// 1.1.声明一个空的 Optional
Optional optCar = Optional.empty();
// 1.2.依据一个非空值创建 Optional，car对象不能为 null
Optional optCar = Optional.of(car);
// 1.3.可接受 null 的 Optional
Optional optCar = Optional.ofNullable(car);

// 2.使用 map 从 Optional 对象中提取和转换值
String name = null;
if(insurance != null){
    name = insurance.getName();
}
// 等价
Optional optInsurance = Optional.ofNullable(insurance);
Optional name = optInsurance.map(Insurance::getName);

// 使用 flatMap 链接 Optional 对象
public String getCarInsuranceName(Person person) {
    return person.getCar().getInsurance().getName();
}
// 等价
Optional optPerson = Optional.of(person);
Optional name =
    optPerson.flatMap(Person::getCar)
             .flatMap(Car::getInsurance)
             .map(Insurance::getName)
             .orElse("Unknown");// 如果 Optional 的结果值为空，设置默认值

// Optional无法序列化的解决方案
public class Person {
    private Car car;
    public Optional getCarAsOptional() {
        return Optional.ofNullable(car);
    }
}

// 3.Optional的方法
/**
get() 是这些方法中最简单但又最不安全的方法。如果变量存在，它直接返回封装的变量值，否则就抛出一个
NoSuchElementException 异常。所以，除非你非常确定 Optional变量一定包含值，否则使用这个方法是个
相当糟糕的主意。此外，这种方式即便相对于嵌套式的 null 检查，也并未体现出多大的改进。

orElse(T other) 允许你在Optional对象不包含值时提供一个默认值。

orElseGet(Supplier other) 是 orElse 方法的延迟调用版， Supplier方法只有在
Optional 对象不含值时才执行调用。如果创建默认值是件耗时费力的工作，你应该考虑采用这种方式（借此提
升程序的性能），或者你需要非常确定某个方法仅在Optional 为空时才进行调用，也可以考虑该方式（这种情
况有严格的限制条件）。

orElseThrow(Supplier exceptionSupplier) 和 get 方法非常类似，它们遭遇 Optional
对象为空时都会抛出一个异常，但是使用 orElseThrow 你可以定制希望抛出的异常类型。

ifPresent(Consumer) 让你能在变量值存在时执行一个作为参数传入的方法，否则就不进行任何
操作。
**/

// 使用
// 不安全，容易发生null异常
public Optional nullSafeFindCheapestInsurance(
    Optional person, Optional car) {
    if (person.isPresent() && car.isPresent()) {
        // get()容易发生null异常
        return Optional.of(findCheapestInsurance(person.get(), car.get()));
    } else {
        return Optional.empty();
    }
}
// 安全
public Optional nullSafeFindCheapestInsurance(
    Optional person, Optional car) {
    // 如果person为null,则flatMap不会执行；如果car为null,则返回一个空的 Optional 对象
    return person.flatMap(p -> car.map(c -> findCheapestInsurance(p, c)));
}


// 使用 filter 剔除特定的值
Insurance insurance = ...;
if(insurance != null && "CambridgeInsurance".equals(insurance.getName())){
    System.out.println("ok");
}
// 
Optional optInsurance = ...;
optInsurance.filter(insurance ->"CambridgeInsurance".equals(insurance.getName()))
.ifPresent(x -> System.out.println("ok"));

public String getCarInsuranceName(Optional person, int minAge) {
return person.filter(p -> p.getAge() >= minAge)
    .flatMap(Person::getCar)
    .flatMap(Car::getInsurance)
    .map(Insurance::getName)
    .orElse("Unknown");
}

// 优化
// 1.用 Optional 封装可能为 null 的值
Object value = map.get("key");
Optional