初识Java 12-3 流

终结操作

将流转换为一个数组（toArray）

在每个流元素上应用某个终结操作（forEach）

收集操作（collect）

组合所有的流元素（reduce）

匹配（*Match）

选择一个元素（find*）

获得流相关的信息

本笔记参考自：《On Java 中文版》

终结操作

||| 终结操作：这些操作会接受一个流，并生成一个最终结果。

终结操作不会把任何东西发给某个后端的流。因此，终结操作总是我们在一个管线内可以做的最后一件事。

将流转换为一个数组（toArray）

可以通过toArray()操作将流转换为数组：

toArray()：将流元素转换到适当的数组中。
toArray(generator)：generator用于在特定情况下分配自己的数组存储。

在流操作生成的内容必须以数组形式进行使用时，toArray()就很有用了：

【例子：将随机数存储在数组中，以流的形式复用】

import java.util.Arrays;
import java.util.Random;
import java.util.stream.IntStream;public class RandInts {private static int[] rints =new Random(47).ints(0, 1000).limit(100).toArray();public static IntStream rands() {return Arrays.stream(rints);}
}

通过这种方式，我们可以保证每次得到的是相同的流。

在每个流元素上应用某个终结操作（forEach）

有两个很常见的终结操作：

forEach(Consumer)
forEachOrdered(Consumer)：这个版本可以确保forEach对元素的操作顺序是原始的流的顺序。

通过使用parallel()操作，可以使forEach以任何顺序操作元素。

parallel()的介绍：这一操作会让Java尝试在多个处理器上执行操作。parallel()可以将流进行分割，并在不同处理器上运行每个流。

下面的例子通过引入parallel()来展示forEachOrdered(Consumer)的作用。

【例子：forEachOrdered(Consumer)的作用】

import static streams.RandInts.*;public class ForEach {static final int SZ = 14;public static void main(String[] args) {rands().limit(SZ).forEach(n -> System.out.format("%d ", n));System.out.println();rands().limit(SZ).parallel().forEach(n -> System.out.format("%d ", n));System.out.println();rands().limit(SZ).parallel().forEachOrdered(n -> System.out.format("%d ", n));System.out.println();}
}

程序执行的结果是：

在第一个流中，因为没有使用parallel()，所以结果显示的顺序就是它们从rands()中出现的顺序。而在第二个流中，parallel()的使用使得输出的顺序发生了变化。这就是因为有多个处理器在处理这个问题（若多执行几次，会发现输出的顺序会不一样，这就是多处理器处理带来的不确定性）。

在最后一个流中，尽管使用了parallel()，但forEachOrdered()使得结果回到了原始的顺序。

所以，对非parallel()的流，使用forEachOrdered()不会有任何影响。

收集操作（collect）

collect(Collector)：使用这个Collector将流元素累加到一个结果集合中。
collect(Supplier, BiConsumer, BiConsumer)：和上一个collect()不同的地方在于：
- Supplier会创建一个新的结果集合。
- 第一个BiConsumer用来将下一个元素包含到结果集合中。
- 第二个BiConsumer用来将两个值进行组合。

collect()的第二个版本，会在每次被调用时，使用Supplier生成一个新的结果集合。这些集合就是通过第二个BiConsumer组合成一个最终结果的。

可以将流元素收集到任何特定种类的集合中。例如：假设我们需要把条目最终放入到一个TreeSet中。尽管Collectors中没有特定的toTreeSet()方法，但我们可以使用Collectors.toCollection()，将任何类型的构造器引用传递给toCollection()。

【例子：将提取的单词放入到TreeSet()中】

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;public class TreeSetOfWords {public static void main(String[] arg) throws Exception {Set<String> words2 =Files.lines(Paths.get("TreeSetOfWords.java")).flatMap(s -> Arrays.stream(s.split("\\W+"))) .filter(s -> !s.matches("\\d+")) // 删除数字.map(String::trim) // 删除可能存在的留白.filter(s -> s.length() > 2).limit(100).collect(Collectors.toCollection(TreeSet::new));System.out.println(words2);}
}

程序执行的结果是：

在这里，Arrays.stream(s.split("\\W+"))会将接收的文本行进行分割，获得的数组会变为Stream，然后其结果又通过flatMap()被展开成一个由单词组成的Stream。

【例子：从流生成一个Map】

import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.Stream;class Pair { // 一个基本的数据对象Pairpublic final Character c;public final Integer i;public Pair(Character c, Integer i) {this.c = c;this.i = i;}public Character getC() {return c;}public Integer getI() {return i;}@Overridepublic String toString() {return "Pair{" +"c=" + c +", i=" + i +'}';}
}class RandomPair {Random rand = new Random(47);// 这是一个无限大的迭代器，指向随机生成的大写字母Iterator<Character> capChars = rand.ints(65, 91) // 65~91，即大写字母对应的ASCII值.mapToObj(i -> (char) i).iterator();public Stream<Pair> stream() { // 生成一个Pair流return rand.ints(100, 1000).distinct() // 移除流中的重复元素.mapToObj(i -> new Pair(capChars.next(), i)); // 组合成Pair对象的流}
}public class MapCollector {public static void main(String[] args) {Map<Integer, Character> map =new RandomPair().stream().limit(8).collect(Collectors.toMap(Pair::getI, Pair::getC));System.out.println(map);}
}

程序执行的结果是：

在大多数情况下，java.util.stream.Collectors中都会存在我们所需的Collector。而如果找不到我们所需要的，这时候就可以使用collect()的第二种形式。

【例子：collect()的第二种形式】

import java.util.ArrayList;public class SpecialCollector {public static void main(String[] arg) throws Exception {ArrayList<String> words =FileToWords.stream("Cheese.dat").collect(ArrayList::new, // 创建新的结果集合ArrayList::add, // 将下一个元素加入集合中ArrayList::addAll); // 组合所有的ArrayListwords.stream().filter(s -> s.equals("cheese")).forEach(System.out::println);}
}

程序执行的结果是：

组合所有的流元素（reduce）

reduce(BinaryOperator)：使用BinaryOperator来组合所有的元素。若流为空，返回一个Optional。
reduce(identity, BinaryOperator)：和上述一致，不同之处在于会将identity作为这个组合的初始值。因此若流为空，会得到一个identity作为结果。
reduce(identity, BiFuncton, BinaryOperator)：BiFunction提供累加器，BinaryOperator提供组合函数。这种形式会更为高效。但若只论效果，可以通过组合显式的map()和reduce()操作来替代。

这些操作之所以使用reduce命名，是因为它们会获取一系列的输入元素，并将它们组合（简化）成一个单一的汇总结果。

【例子：reduce()操作的演示】

import java.util.Random;
import java.util.stream.Stream;class Frobnitz {int size;Frobnitz(int sz) {size = sz;}@Overridepublic String toString() {return "Frobnitz{" +"size=" + size +'}';}// 生成器static Random rand = new Random(47);static final int BOUND = 100;static Frobnitz supply() {return new Frobnitz(rand.nextInt(BOUND));}
}public class Reduce {public static void main(String[] args) {Stream.generate(Frobnitz::supply).limit(10).peek(System.out::println).reduce((fr0, fr1) -> fr0.size < 50 ? fr0 : fr1) // 若fr0的size小于50，接受fr0，否则接受fr1.ifPresent(System.out::println);}
}

程序执行的结果是：

Forbnitz有一个自己的生成器，叫做supply()。在上述例子中，我们把方法引用Frobnitz::supply传递给了Stream.generate，因为它和Supplier<Frobnitz>是签名兼容的（又称结构一致性）。

Supplier是一个函数式接口。在这里Supplier<Frobnitz>相当于一个返回Frobnitz对象的无参函数。

在使用reduce()时，我们没有使用identity作为初始值。这意味着reduce()会生成一个Optional，当结果不为empty时，才会执行Consumer<Frobnitz>（即lambda表达式）。再看lambda表达式本身：

(fr0, fr1) -> fr0.size < 50 ? fr0 : fr1

其中的第一个参数fr0是上次调用这个reduce()时带回的结果，第二个参数fr1是来自流中的新值。

匹配（*Match）

allMatch(Predicate)：通过Predicate检测流中的元素，若每一个元素结果都为true，则返回true。若遇到false，则发生短路 —— 在遇到第一个false后，停止计算。
anyMatch(Predicate)：同样使用Predicate进行检测，若任何一个元素得到true，则返回true。在遇到第一个true时，发生短路。
noneMatch(Predicate)：进行检测，若没有元素得到true，则返回true。在遇到第一个true时，发生短路。

【例子：Match引发的短路行为】

import java.util.function.BiPredicate;
import java.util.function.Predicate;
import java.util.stream.IntStream;
import java.util.stream.Stream;interface Matcher extends // 能够匹配所有的Stream::*Match函数的模式BiPredicate<Stream<Integer>, Predicate<Integer>> {
}public class Matching {static void show(Matcher match, int val) {System.out.println(match.test(IntStream.rangeClosed(1, 9) // 返回一个从1~9递增的Integer序列.boxed().peek(n -> System.out.format("%d ", n)),n -> n < val));}public static void main(String[] args) {show(Stream::allMatch, 10);show(Stream::allMatch, 4);show(Stream::anyMatch, 2);show(Stream::anyMatch, 0);show(Stream::noneMatch, 5);show(Stream::noneMatch, 0);}
}

程序执行的结果是：

BiPredicate是一个二元谓词，所以他会接受两个参数，并返回true和false。其中，第一个参数是我们要测试的数值的流，第二个参数是谓词Predicate本身。

选择一个元素（find*）

findFirst()：返回一个Optional，其中包含了流中的第一个元素。若流中没有元素，则返回Optional.empty。
findAny()：返回一个Optional，其中包含了流中的某个元素。若流中没有元素，则返回Optional.empty。

【例子：find*操作的使用】

import static streams.RandInts.*;public class SelectElement {public static void main(String[] args) {System.out.println(rands().findFirst().getAsInt());System.out.println(rands().parallel().findFirst().getAsInt());System.out.println(rands().findAny().getAsInt());System.out.println(rands().parallel().findAny().getAsInt());}
}

程序执行的结果是：

无论流是否并行，findFirst()总会选择流中的第一个元素。但findAny()有些不同，在非并行的流中，findAny()会选择第一个元素，而当这个流是并行流时，findAny()有可能选择第一个元素之外的元素。

若需要某个流中的最后一个元素，可以使用reduce()：

【例子：选择流中的最后一个元素】

import java.util.Optional;
import java.util.OptionalInt;
import java.util.stream.IntStream;
import java.util.stream.Stream;public class LastElement {public static void main(String[] args) {OptionalInt last = IntStream.range(10, 20).reduce((n1, n2) -> n2);System.out.println(last.orElse(-1));// 对于非数值对象Optional<String> lastobj =Stream.of("one", "two", "three").reduce((n1, n2) -> n2);System.out.println(lastobj.orElse("不存在任何元素"));}
}

程序执行的结果是：

reduce((n1, n2) -> n2)语句可以用两个元素这的后一个替换这两个元素，通过这种方式就可以获得流中的最后一个元素了。

获得流相关的信息

count()：获得流中元素的数量。
max(Comparator)：通过Comparator确定这个流中的“最大元素”。
min(Comparator)：确定这个流中的“最小元素”。

【例子：使用String预设的Comparator获取信息】

public class Informational {public static void main(String[] args) throws Exception {System.out.println(FileToWords.stream("Cheese.dat").count());System.out.println(FileToWords.stream("Cheese.dat").min(String.CASE_INSENSITIVE_ORDER).orElse("NONE"));System.out.println(FileToWords.stream("Cheese.dat").max(String.CASE_INSENSITIVE_ORDER).orElse("NONE"));}
}

程序执行的结果是：

其中，max()和min()都会返回Optional，这里出现的orElse()是用来获取其中的值的。

获得数值化流相关的信息

average()：获得平均值。
max()和min()：因为处理的是数值化的流，所以不需要Comparator。
sum()：将流中的数值进行累加。
summaryStatistics()：返回可能有用的摘要数据（但我们也可以使用直接方法获取这些数据）。

【例子：数值化流的信息获取（以IntStream为例）】

import static streams.RandInts.*;public class NumericStreamInfo {public static void main(String[] args) {System.out.println(rands().average().getAsDouble());System.out.println(rands().max().getAsInt());System.out.println(rands().min().getAsInt());System.out.println(rands().sum());System.out.println(rands().summaryStatistics());}
}

程序执行的结果是：