JDK新特性•全盘点

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

什么是流

流只能消费一次

流操作会改变源数据

集合与流

使用Collection接口需要用户去做迭代（比如用for-each），这称为外部迭代。相反，Streams库使用内部迭代——它帮你把迭代做了，还把得到的流值存在了某个地方，你只要给出一个函数说要干什么就可以了。

内部迭代与外部迭代

可以连接起来的流操作称为中间操作，关闭流的操作称为终端操作。

诸如filter或sorted等中间操作会返回另一个流。这让多个操作可以连接起来形成一个查询。重要的是，除非流水线上触发一个终端操作，否则中间操作不会执行任何处理——它们很懒。这是因为中间操作一般都可以合并起来，在终端操作时一次性全部处理。

终端操作会从流的流水线生成结果。其结果是任何不是流的值，比如List、Integer，甚至void。

limit具有短路性，即找到满足需要的数据后不会迭代剩余的数据

limit

中间操作不会执行实际的计算，需要终端操作来触发。

中间操作可以链接起来，将一个流转换为另一个流。这些操作不会消耗流，其目的是建立一个流水线。与此相反，终端操作会消耗流，以产生一个最终结果，例如返回流中的最大元素。

中间操作与终端操作

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

流的流水线背后的理念类似于构建器模式。在构建器模式中有一个调用链用来设置一套配置（对流来说这就是一个中间操作链），接着是调用built方法（对流来说就是终端操作）。

filter

distinct

skip

筛选和切片

map

如果map返回的是多个流，使用flatMap会把它们合并成一个流

flatMap

映射

另一个常见的数据处理套路是看看数据集中的某些元素是否匹配一个给定的属性。StreamAPI通过allMatch、anyMatch、noneMatch、findFirst和findAny方法提供了这样的工具。具有短路性。

为什么会同时有findFirst和findAny呢？答案是并行。找到第一个元素在并行上限制更多。如果你不关心返回的元素是哪个，请使用findAny，因为它在使用并行流时限制较少。

查找和匹配

Lambda反复结合每个元素，直到流被归约成一个值。

reduce

归约

Java8引入了三个原始类型特化流接口来解决暗含的装箱问题：IntStream、DoubleStream和LongStream，分别将流中的元素特化为int、long和double，从而避免了暗含的装箱成本。 

将流转换为特化版本的常用方法是mapToInt、mapToDouble和mapToLong。

原始流转化为数值流

要把原始流转换成一般流（每个int都会装箱成一个Integer），可以使用boxed方法

数值流转化为原始流

和数字打交道时，有一个常用的东西就是数值范围。比如，假设你想要生成1和100之间的所有数字。Java8引入了两个可以用于IntStream和LongStream的静态方法，帮助生成这种范围：range和rangeClosed。这两个方法都是第一个参数接受起始值，第二个参数接受结束值。但range是不包含结束值的，而rangeClosed则包含结束值。

数值范围

找出1到1000以内所有的勾股值

数值流

由集合创建

你可以使用静态方法Stream.of，通过显式值创建一个流。它可以接受任意数量的参数。

Stream<String> stream=Stream.of(\"Java8\

Stream<String> emptyStream=Stream.empty();

由值创建流

你可以使用静态方法Arrays.stream从数组创建一个流。它接受一个数组作为参数。

由数组创建流

Java中用于处理文件等I/O操作的NIOAPI（非阻塞I/O）已更新，以便利用StreamAPI。java.nio.file.Files中的很多静态方法都会返回一个流。例如，一个很有用的方法是Files.lines，它会返回一个由指定文件中的各行构成的字符串流。

由文件生成流

StreamAPI提供了两个静态方法来从函数生成流：Stream.iterate和Stream.generate。这两个操作可以创建所谓的无限流：不像从固定集合创建的流那样有固定大小的流。由iterate和generate产生的流会用给定的函数按需创建值，因此可以无穷无尽地计算下去！一般来说，应该使用limit(n)来对这种流加以限制，以避免打印无穷多个值。

iterate方法接受一个初始值（在这里是0），还有一个依次应用在每个产生的新值上的Lambda（UnaryOperator<t>类型）。

单词意思:重复

iterate

与iterate方法类似，generate方法也可让你按需生成一个无限流。但generate不是依次对每个新生成的值应用函数的。它接受一个Supplier<T>类型的Lambda提供新的值。

Stream.generate(Math::random).limit(5).forEach(System.out::println);

generate

使用limit限制大小，避免无限流

由函数生成流：创建无限流

构建流

使用流

它遍历流中的每个元素，并让Collector进行处理。

collect()方法

用Collectors类创建和使用收集器（Collector）

将数据流归约为一个值

汇总：归约的特殊情况

Collectors.groupingBy

我们把这个Function叫作分类函数，因为它用来把流中的元素分成不同的组。分组操作的结果是一个Map，把分组函数返回的值作为映射的键，把流中所有具有这个分类值的项目的列表作为对应的映射值。

要实现多级分组，我们可以使用一个由双参数版本的Collectors.groupingBy工厂方法创建的收集器，它除了普通的分类函数之外，还可以接受collector类型的第二个参数。那么要进行二级分组的话，我们可以把一个内层groupingBy传递给外层groupingBy，并定义一个为流中项目分类的二级标准

多级分组

传递给第一个groupingBy的第二个收集器可以是任何类型，而不一定是另一个groupingBy。例如，要数一数菜单中每类菜有多少个，可以传递counting收集器作为groupingBy收集器的第二个参数

把收集器返回的结果转换为另一种类型，你可以使用Collectors.collectingAndThen工厂方法返回的收集器

把收集器的结果转换为另一种类型

按子组收集数据

分组

Collectors.partitioningBy

分区是分组的特殊情况：由一个谓词（返回一个布尔值的函数）作为分类函数，它称分区函数。分区函数返回一个布尔值，这意味着得到的分组Map的键类型是Boolean，于是它最多可以分为两组——true是一组，false是一组。例如，如果你是素食者或是请了一位素食的朋友来共进晚餐，可能会想要把菜单按照素食和非素食分开

使用方法和分组类似

分区

数据分组和分区

Collector会对元素应用一个转换函数（很多时候是不体现任何效果的恒等转换，例如toList），并将结果累积在一个数据结构中，从而产生这一过程的最终输出。

一个创建并返回新的可变结果容器的函数。

Supplier<A> supplier();

将值折叠到可变结果容器中的函数。

一个接受两个部分结果并合并它们的函数。 组合器函数可以将状态从一个参数折叠到另一个参数并返回该参数，或者可以返回新的结果容器。

BinaryOperator<A> combiner();

在遍历完流后，finisher方法必须返回在累积过程的最后要调用的一个函数，以便将累加器对象转换为整个集合操作的最终结果。通常，就像ToListCollector的情况一样，累加器对象恰好符合预期的最终结果，因此无需进行转换。所以finisher方法只需返回identity函数

最后一个方法——characteristics会返回一个不可变的Characteristics集合，它定义了收集器的行为——尤其是关于流是否可以并行归约，以及可以使用哪些优化的提示。Characteristics是一个包含三个项目的枚举。

Set<Characteristics> characteristics();

有五个

收集器Collector接口

开发自己的自定义收集器

用流收集数据

调用流的parallel()方法

将顺序流转换为并行流

内部分块处理，然后将各块的结果合并

实现原理

如果一个流程里面调用了sequential和parallel方法，以最后调用的方法为准

调用流的sequential()方法

将并行流转换为顺序流

看看流的parallel方法，你可能会想，并行流用的线程是从哪儿来的？有多少个？怎么自定义这个过程呢？并行流内部使用了默认的ForkJoinPool（7.2节会进一步讲到分支/合并框架），它默认的线程数量就是你的处理器数量，这个值是由Runtime.getRuntime().availableProcessors()得到的。但是你可以通过系统属性java.util.concurrent.ForkJoinPool.common.parallelism来改变线程池大小，如下所示：System.setProperty(\"java.util.concurrent.ForkJoinPool.common.parallelism\

配置并行流使用的线程池

iterate生成的流本质上是顺序的，因为每次计算都会依赖上一次计算的结果

并行流并不总比顺序流快，涉及到装箱拆箱操作

留意装箱

有些操作本身在并行流上的性能就比顺序流差。特别是limit和findFirst等依赖于元素顺序的操作，它们在并行流上执行的代价非常大。例如，findAny会比findFirst性能好，因为它不一定要按顺序来执行。你总是可以调用unordered方法来把有序流变成无序流。那么，如果你需要流中的n个元素而不是专门要前n个的话，对无序并行流调用limit可能会比单个有序流（比如数据源是一个List）更高效。

还要考虑终端操作中合并步骤的代价是大是小（例如Collector中的combiner方法）。如果这一步代价很大，那么组合每个子流产生的部分结果所付出的代价就可能会超出通过并行流得到的性能提升。

要考虑流背后的数据结构是否易于分解。例如，ArrayList的拆分效率比LinkedList高得多，因为前者用不着遍历就可以平均拆分，而后者则必须遍历。另外，用range工厂方法创建的原始类型流也可以快速分解。最后，你将在7.3节中学到，你可以自己实现Spliterator来完全掌控分解过程。

什么时候利用并行流来提高性能

避免共享可变状态

ArrayList  极好

LinkedList 差

IntStream.range 极好

Stream.iterate 差

HashSet 好

TreeSet 好

常见数据源的可分解性，可分解性影响是否适合并行

并行流

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

分支/合并框架

Spliterator是Java8中加入的另一个新接口；这个名字代表“可分迭代器”（splitableiterator）。和Iterator一样，Spliterator也用于遍历数据源中的元素，但它是为了并行执行而设计的。

boolean tryAdvance(Consumer<? super T> action);

Spliterator<T> trySplit();

内部方法

子主题

Spliterator

并行数据处理与性能

底层线程数量固定

stream

接受至少一个函数作为参数

返回的结果是一个函数

能满足下面任一要求就可以被称为高阶函数

高阶函数

科里化

破坏式更新

没有改动任何现存的数据结构

函数式更新

Java8的Stream以其延迟性而著称。它们被刻意设计成这样，即延迟操作，有其独特的原因：Stream就像是一个黑盒，它接收请求生成结果。当你向一个Stream发起一系列的操作请求时，这些请求只是被一一保存起来。只有当你向Stream发起一个终端操作时，才会实际地进行计算。这种设计具有显著的优点，特别是你需要对Stream进行多个操作时（你有可能先要进行filter操作，紧接着做一个map，最后进行一次终端操作reduce）；这种方式下Stream只需要遍历一次，不需要为每个操作遍历一次所有的元素。

Stream的延迟计算

持久化数据结构

函数式编程的技巧

它让类可以自动地继承接口的一个默认实现

api的变化不会影响现有实现类

目的

如果一个类使用相同的函数签名从多个地方（比如另一个类或接口）继承了方法，通过三条规则可以进行判断

(1)类中的方法优先级最高。类或父类中声明的方法的优先级高于任何声明为默认方法的优先级

（1）

如果无法依据第一条进行判断，那么子接口的优先级更高：函数签名相同时，优先选择拥有最具体实现的默认方法的接口，即如果B继承了A，那么B就比A更加具体

（2）

最后，如果还是无法判断，继承了多个接口的类必须通过显式覆盖和调用期望的方法，显式地选择使用哪一个默认方法的实现

（3）

Xxx.supper.hello（）

public void hello() {OSO.super.hello(); }

如果显示调用接口的方法

冲突解决规则

默认方法

接口

CompletableFuture：组合式异步编程

告诉程序怎么做

命令式编程

把最终如何实现的细节留给了函数库。我们把这种思想称之为内部迭代。它的巨大优势在于你的查询语句现在读起来就像是问题陈述，由于采用了这种方式，我们马上就能理解它的功能，比理解一系列的命令要简洁得多。

告诉程序要做什么

声明式编程

函数式编程具体实践了前面介绍的声明式编程（“你只需要使用不相互影响的表达式，描述想要做什么，由系统来选择如何实现”）和无副作用计算。

它们能让我们的程序更便于阅读，易于编写。

为什么要采用函数式编程

如果一个函数只要传递同样的参数值，总是返回同样的结果，那这个函数就是引用透明的。

引用透明性

函数式的思考

在使用函数式接口的地方

在哪里可以使用

方法引用是lamda表达式的快捷写法这种类型的lamda表达式 (Shapshot.User u)->u.isMan()

什么是方法引用

(1)指向静态方法的方法引用（例如Integer的parseInt方法，写作Integer::parseInt）。(2)指向任意类型实例方法的方法引用（例如String的length方法，写作String::length）。(3)指向现有对象的实例方法的方法引用（假设你有一个局部变量expensiveTransaction用于存放Transaction类型的对象，它支持实例方法getValue，那么你就可以写expensiveTransaction::getValue）。 

有几种

Supplier<Apple> c1=Apple::new;←─构造函数引用指向默认的Apple()构造函数Apple a1=c1.get();←─调用Supplier的get方法将产生一个新的Apple  

Supplier<Apple> c1=()->new Apple();←─利用默认构造函数创建Apple的Lambda表达式Apple a1=c1.get();←─调用Supplier的get方法将产生一个新的Apple 

上面二者等价

构造函数方法引用

方法引用

只定义一个抽象方法的接口

可以有几个抽象方法

java.util.function包下

官方预定义好的函数式接口在哪里

函数式接口

谓词接口包括三个方法：negate、and和or，让你可以重用已有的Predicate来创建更复杂的谓词。

请注意，and和or方法是按照在表达式链中的位置，从左向右确定优先级的。因此，a.or(b).and(c)可以看作(a||b)&&c。

谓词复合

inventory.sort(comparing(Apple::getWeight).reversed());←─按重量递减排序

逆序

inventory.sort(comparing(Apple::getWeight).reversed() ←─ 按重量递减排序 .thenComparing(Apple::getCountry)); ←─ 两个苹果一样重时，进一步按国家排序

比较器链

比较器复合

你还可以把Function接口所代表的Lambda表达式复合起来。Function接口为此配了andThen和compose两个默认方法，它们都会返回Function的一个实例。

函数复合

复合Lambda表达式

lamda表达式

是将实现单一抽象方法的匿名类转换为Lambda表达式

this   supper

匿名类屏蔽类变量

重载

注意点

从匿名类到Lambda表达式的转换

Lambda表达式非常适用于需要传递代码片段的场景。不过，为了改善代码的可读性，也请尽量使用方法引用。因为方法名往往能更直观地表达代码的意图。

抽取lamda表达式的内容到单独的方法里面，然后传递方法引用

尽量考虑使用静态辅助方法，比如comparing、maxBy

很多通用的归约操作，比如sum、maximum，都有内建的辅助方法可以和方法引用结合使用

从Lambda表达式到方法引用的转换

将所有使用迭代器这种数据处理模式处理集合的代码都转换成StreamAPI的方式

StreamAPI能更清晰地表达数据处理管道的意图。除此之外，通过短路和延迟载入以及利用第7章介绍的现代计算机的多核架构，我们可以对Stream进行优化。

考虑控制流语句，比如break、continue、return

找工具转换

从命令式的数据处理切换到Stream

没有函数接口，你就无法使用Lambda表达式

如果你发现你需要频繁地从客户端代码去查询一个对象的状态（比如前文例子中的日志器的状态），只是为了传递参数、调用该对象的一个方法（比如输出一条日志），那么可以考虑实现一个新的方法，以Lambda或者方法表达式作为参数，新方法在检查完该对象的状态之后才调用原来的方法。

有条件的延迟执行

如果你发现虽然你的业务代码千差万别，但是它们拥有同样的准备和清理阶段，这时，你完全可以将这部分代码用Lambda实现。这种方式的好处是可以重用准备和清理阶段的逻辑，减少重复冗余的代码

环绕执行

采用函数接口

增加代码灵活性

为改善可读性和灵活性重构代码

对设计经验的归纳总结被称为设计模式

用lamda表达式代替具体的实现类

策略模式

如果你需要采用某个算法的框架，同时又希望有一定的灵活度，能对它的某些部分进行改进，那么采用模板方法设计模式是比较通用的方案

接口参数添加函数式接口，方便直接传lamda表达式，而不用通过继承来实现

模板方法

某些事件发生时（比如状态转变），如果一个对象（通常我们称之为主题）需要自动地通知其他多个对象（称为观察者），就会采用该方案

如果逻辑很简单的观察者模式可以直接用lamda表达式

观察者模式

责任链模式是一种创建处理对象序列（比如操作序列）的通用方案。一个处理对象可能需要在完成一些工作之后，将结果传递给另一个对象，这个对象接着做一些工作，再转交给下一个处理对象，以此类推

责任链模式?

使用工厂模式，你无需向客户暴露实例化的逻辑就能完成对象的创建

return new XXX() 的地方换成 XXX::new

工厂模式

使用Lambda重构面向对象的设计模式

判断返回结果和预期结果是否一致

测试lamda表达式

使用lambda表达式和非相同类的方法引用导致栈跟踪不易理解

查看栈跟踪

它不像forEach那样恢复整个流的运行，而是在一个元素上完成操作之后，它只会将操作顺承到流水线中的下一个操作

流的peek方法

输出日志

调试

重构/测试和调试

        Optional<String> optional=Optional.empty(); 

空的

        Optional<String> optional=Optional.of(\"hello\"); 

包含非空值的

        Optional<String> optional=Optional.ofNullable(\"hello\"); 

包含可为空值的

创建optional

        Optional<Integer> optionalInteger=optional.map(String::length); 

map操作的结果是一个Optional<Optional<Car>>，则flatMap得到Optional<Car>

以不解包的方式组合两个Optional对象

使用map从Optional对象中提取和转换值

不要写在域模型里面，因为optional对象不支持序列化

有则返回，无则报异常

get()

有则返回，无则返回给定值

orElse(T other)

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

orElseGet(Supplier<? extends T> other)

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

T orElseThrow(Supplier<? extends X> exceptionSupplier)

有则用传入的方法消费这个对象

ifPresent(Consumer<? super T> consumer)

optional取值

filter方法接受一个谓词作为参数。如果Optional对象的值存在，并且它符合谓词的条件，filter方法就返回其值；否则它就返回一个空的Optional对象

filter(Predicate<? super T> predicate)

optional filter

因为基础类型的Optional不支持map、flatMap以及filter方法，而这些却是Optional类最有用的方法

避免使用optional对象的基础类

在需要进行空值判断的地方使用有奇效

用optional取代null

Date和Calendar都是可变的

Dateformat不是线程安全的

为什么在java8中引入新的时间和日期库

静态方法，of创建

LocalDate

LocalTime

Instant

Duration

Period

ZonedDateTime

DateTimeFormatter

你现在可以按照特定的格式需求，定义自己的格式器，打印输出或者解析日期-时间对象。这些格式器可以通过模板创建，也可以自己编程创建，并且它们都是线程安全的。

TemporalAdjuster

java8的时间和日期api

你可以用绝对或者相对的方式操纵日期和时间，操作的结果总是返回一个新的实例，老的日期时间对象不会发生变化。

新的API提供了两种不同的时间表示方式，有效地区分了运行时人和机器的不同需求。

新版的日期和时间API中，日期-时间对象是不可变的。

Java8之前老版的java.util.Date类以及其他用于建模日期时间的类有很多不一致及设计上的缺陷，包括易变性以及糟糕的偏移值、默认值和命名。

特点

新的日期和时间api

JDK新特性•全盘点