目录
本笔记参考自： 《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 { // 一个基本的数据对象Pair
public 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;
}
@Override
public 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); // 组合所有的ArrayList
words.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;
}
@Override
public 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());
}
}程序执行的结果是：
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
