“核心技术Ⅱ：流”的版本间差异

2020年11月24日 (二) 05:57的版本

关于 Java SE 8 的流库

Stream它并不是一个容器，它只是对容器的功能进行了增强，添加了很多便利的操作,例如查找、过滤、分组、排序等一系列的操作。

并且有串行、并行两种执行模式，并行模式充分的利用了多核处理器的优势，使用fork/join框架进行了任务拆分，同时提高了执行速度。

简而言之，Stream就是提供了一种高效且易于使用的处理数据的方式。

流提供了一种在比集合更高的概念级别上指定计算的数据视图，以“做什么而非怎么做”的方式处理集合。

从迭代到流的操作

处理集合时，通常会迭代遍历它的元素，并在每个元素上执行某项操作：

String contents = new String(Files.readAllBytes(Paths.get("alice.txt")), Standard(harsets,UTF_8); // Read file into string
List<String> words= Arrays.aslist(contents.split("\\PL+")); // Split into words; nonletters are delimiters

long count = O;
for (String w : words)
{
   if (w. length() > 12) 
      count++;
}

使用流时，相同的操作看起来像下面这样：

1ong count = words.stream().filter(w -> w.length() > 12).count();

仅将stream 修改为parallelStream 就可以让流库以并行方式来执行过滤和计数：
```
1ong count = words.parallelStream().filter(w -> w.length() > 12).count();
```

以上：

stream 和parallel Stream 方法会产生一个用于words 列表的stream。
filter 方法会返回另一个流，其中只包含长度大于12 的单词。
count 方法会将这个流化简为一个结果。

流与集合

流表面上活起来和集合很类似，都可以让我们转换和获取数据。但是，它们之间存在着显著的差异：

流并不存储其元素。
这些元素可能存储在底层的栠合中，或者是按需生成的。
流的操作不会修改其数据源。
例如，filter 方法不会从新的流中移除元素，而是会生成一个新的流，其中不包含被过滤掉的元素。
流的操作是尽可能惰性执行的。这意味若直至需要其结果时，操作才会执行。
例如，如果我们只想查找前5 个长单词而不是所有长单词，那么filter 方法就会在匹配到第5 个单词后停止过滤。因此，我们甚至可以操作无限流。

流的创建

集合转换为流：
用“Collection.stream()”方法将任何集合转换为一个流。
数组转换为流：
1. 使用“Array.stream(array, from, to)”可以从数组中位于from (包括）和to (不包括）的元索中创建一个流。
2. 使用Stream静态的“of”方法，将数组转换为流：
  Stream<String> words= Stream.of(contents.split("\\PL+")); // split returns a String[] array
  - of 方法具有可变长参数，因此我们可以构建具有任意数趾引元的流：
    Stream<String> song = Stream.of("gently", "down", "the", "stream");

空流：

使用静态的Stream.empty 方法，创建不包含任何元素的流；

Stream<String> silence = Stream.empty();   // Generic type <String> is inferred; same as St ream. <St ri ng>empty()

无限流：

generate 方法：接受一个不包含任何引元的函数（或者从技术上讲，是一个Supplier<T> 接口的对象）。

Stream<String> echos = Stream.generate(() -> "Echo");   // 获得一个常批值的流：
Stream<Double> randoms = Stream.generate(Math:: random);   // 获得一个随机数的流：

iterate 方法：接受一个“种子”值，以及一个函数（从技术上讲，是一个UnaryOperation<T>), 并且会反复地将该函数应用到之前的结果上。

Strea价<BigInteger> integers = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));
// 第一个元素是种子Biglnteger.ZERO, 第二个元素是f(seed), 即l (作为大整数），下一个元素是f(f(seed)), 即2, 后续以此类推。

Java API中的其他流方法：

Pattern 类有一个“splitAsStream”方法，它会按照某个正则表达式来分割一个“CharSequence”对象：
```
Stream<String> words = Pattern,compile("\\PL+").splitAsStream(contents);
```

静态的“Files.lines”方法会返回一个包含了文件中所有行的Stream：

try (Stream<String> lines = Files.lines (path))
{
   ...Process lines...
}

流的转换

流的转换会产生一个新的流，它的元素派生自另一个流中的元素。

filter 、map 和 flatMap 方法

filter 转换会产生一个流，它的元素与某种条件相匹配。
filter 的引元是Predicate<T>, 即从T 到boolean 的函数。
```
List<String> wordlist = . . . ;
Stream<String> longwords = wordlist.stream().filter(w -> w. length() > 12);
```

map 方法用于按照某种方式来转换流中的值。

// 1、使用函数式接口：
Stream<String> lowercaseWords = words.stream().map(String::tolowerCase);
// 2、或者使用lambda替换：
Stream<String> firstletters = words.stream().map(s -> s.substring(O, 1));

flatMap 方法用于“摊平由流构成的流”。

（即，将包含流的流，变为流）

// 1、
Stream<Stream<String>> result = words.stream() .map(w -> letters(w));
// 2、
Stream<String> flatResult = words.stream().flatMap(w -> letters(w));

letters：
public static Stream<String> letters(String s)
{
   List<Stri ng> result = new Array List<>();
   for (int i = O; i < s.length(); i++)
      result.add(s.substring(i, i + 1));
   return result.stream();
}

// 若 w 为“[[your][boat]]”；
// 1、结果为“[...["y","o", "u" ,"r"),["b" ,"o" ,"a" ,"t"],...]”；
// 2、结果为“[..."y","o","u" ,"r", "b","o" ,"a" ,"t",...],”；

抽取子流和连接流

stream.limit(n)：会返回一个新的流，它在n个元素之后结束（如果原来的流更短，那么就会在流结束时结束）。
（对于裁剪无限流的尺寸特别有用。）
```
Stream<Doub1e> randoms = Stream.generate(Math::random).1imit(lOO);   // 会产生一个包含100 个随机数的流
```

stream.skip(n)：会丢弃前n个元素。

（在将文本分隔为单词时会显得很方便。）

Stream<String> words = Stream.of(contents.split("\\PL+")).skip(l);   // 会跳过split方法产生字符串的第一个字符（空字符串）

Stream.concat(Stream<? extends T> a, Stream<? extends T> b)：静态方法，用于拼接两个流。
- 第一个流不应该是无限的，否则第二个流没有处理机会。
```
Stream<String> combined= Stream.concat(1etters("Hello"), 1etters("Wor1d"));   // Yields the stream ["H", "e", "l", "1", "o", "W", "o", "r", "l", "d")
```

其他的流转换

distinct：方法会返回一个流，它的元素是从原有流中，按照同样的顺序剔除重复元素后产生的。

Stream<String> uniqueWords = Stream.of("merrily", "merrily", "merrily", "gently").distinct();  // Only one "merrily" is retained

sorted：方法会返回一个流，它的元素是原有流中按照顺序排列的元素。
（有多种sorted方法的变体可用：一种用于操作“Comparable”元素的流，另一种可以接受一个“Comparator”）
```
Stream<String> longestFirst = words.stream().sorted(Comparator.comparing(String::1ength).reversed());
```

peek：元素与原来流中的元索相同，但是在每次获取一个元素时，都会调用一个函数。

（对于调试可以让peek调用一个设置断点的方法。）

Object[] powers= Stream.iterate(l.O, p -> p * 2).peek(e -> System.out.println("Fetching" + e)).1imit(20).toArray();
// 当实际访问一个元素时，就会打印出来一条消息。

流的终止操作

流的终止操作：即从流数据中获得答案。

简单约简

约简是一种终结操作(tennjnal operation), 它们会将流约简为可以在程序中使用的非流值。

这些方法返回的是一个类型“Optional<T>”的值，它要么在其中包装了答案，要么表示没有任何值（因为流碰巧为空）。

常用的简单约简：

“count”方法，会返回流中元素的数量；

“max”、“min”方法，会返回流中元素的最大值和最小值；

Optional<String> largest = words.max(String::compareToignoreCase);
System.out.println("largest: " + largest.orElse(""));

“findFirst”方法，返回的是非空集合中的第一个值；

（通常会在与filter 组合使用时显得很有用）

Optional<String> startsWithQ = words.filter(s -> s.startsWith("Q")).findFirst();   // 找到第一个以字母Q 开头的单词

“findAny”方法，返回的是非空集合中的任意匹配值；

Optional<String> startsWithQ = words.parallel().filter(s -> s.startsWith("Q")).findAny();

“anyMatch”方法，只返回是否存在匹配；
（这个方法会接受一个断言引元Predicate，因此不需要使用filter）
```
boolean aWordStartsWithQ = words.parallel().anyMatch(s -> s.startsWith("Q"));
```
“allMatch”方法，在所有元素匹配断言的情况下返回true；
“noneMatch”方法，在没有任何元素匹配断言的情况下返回true；

Optional 类型

Optional<T> 对象是一种包装器对象，要么包装了类型T 的对象，要么没有包装任何对象。

Optional<T> 类型被当作一种更安全的方式，用来替代类型T 的引用，这种引用要么引用某个对象，要么为null。

如何使用Optional值

使用Optional 的关键：

在值不存在的情况下会产生一个可替代物；

// 在没有任何匹配时：使用某种默认值，可能是空字符串：
String result= optionalString.orElse('"');   // The wrapped string, or "" if none

// 调用代码来计算默认值：
String result= optionalString.orElseGet(() -> Locale.getDefault().getDisplayName());   // The function is only called when needed

// 在没有任何值时抛出异常：
String resu 1t = opti ona 1 String. orEl se Throw(Illega1StateException::new);   // Supply a method that yi e 1 ds an exception object

在值存在的情况下才会使用这个值。

“ifPresent”方法：接受一个函数。如果该可选值存在，那么它会被传递给该函数。否则不会发生任何事情。
（当调用ifPresent 时，从该函数不会返回任何值。如果想要处理函数的结果，应该使用map）

// 1、使用ifPresent来调用函数处理optionalValue
optionalValue.ifPresent(v -> Process v);   // 调用Process处理v

// 2、将其添加到某个集中
optionalValue.ifPresent(v -> results.add(v));
optionalValue.ifPresent(results::add);   // 或使用函数式接口


// 当调用ifPresent时，从该函数不会返回任何值。如果想要处理函数的结果，应该使用map:
Optional<Boo1ean> added = optianalVa1ue.map(results::add);
// 现在added 具有三种值之一：
// 在optionalValue存在的情况下包装在Optional中的true或false, 以及在optionalValue不存在的情况下的空Optional。

不适合使用Optional值的方式

【？？？】

如果没有正确地使用Optional 值，那么相比较以往的得到“某物或null”的方式，你并没有得到任何好处。

get 方法会在Optional 值存在的情况下获得其中包装的元素，或者在不存在的情况下抛出一个NoSuchElementException 对象。因此，
   Optional <T> optionalValue = ...;
   optionalValue.get().someMethod();
并不比下面的方式更安全：
   T value = ...;
   va1ue.someMethod();
   
isPresent 方法会报告某个Optional<T> 对象是否具有一个值。但是
   if (optionalVa1ue.isPresent()) optionalValue.get().someMethod();
并不比下面的方式更容易处理：
   if (value != null) value.someMethod();

创建Optional 值

有多个方法可以创建Optional 对象：

“Optional.of(result)”
“Optional.empty()”
“Optional.ofNullable(obj)”：在obj 不为null 的情况下返回“Optional.of(obj)”, 否则会返回“Optional.empty()”。
```
public static Optional<Double> inverse(Double x)
{
   return x = 0 ? Optional.empty() : Optional.of(l / x);
}
```

用flatMap 来构建Optional值的函数

（类比于“stream.flatMap()”）

“ptional.flatMap()”用来将流计算过程中的方法连接起来：

假设你有一个可以产生Optional<T> 对象的方法f, 并且目标类型T 具有一个可以产生Optional<U> 对象的方法g。如果它们都是普通的方法，那么你可以通过调用“s.f().g()”来将它们组合起来。

但是这种组合没法工作，因为“s.f()”的类型为Optional<T>, 而不是T。因此，需要调用：
   Optional<U> result= s.f().flatMap(T::g);
   如果s.f() 的值存在，那么g 就可以应用到它上面。否则，就会返回一个空Optional<U> 。

很明显，如果有更多的可以产生Optional 值的方法或Lambda 表达式，那么就可以重复此过程。

可以直接将对flatMap 的调用链接起来，从而构建由这些步骤构成的管道，只有所有步骤都成功时，该管道才会成功。

public static Optional<Double> squareRoot(Double x)
{
   return x<0 ? Optional.empty() : Optional.of(Math.sqrt(x));
}

// 计算倒数的平方根：
Optional<Double> result = inverse(x).flatMap(MyMath::squareRoot);
// 或者，你可以选择下面的方式：
Optional<Double> result = Optional.of(-4.0).flatMap(MyMath::inverse).flatMap(MyMath::squareRoot);

收集结果

当处理完流之后，通常会想要查看、收集其元素。

查看元素

调用“iterator”方法，它会产生可以用来访问元素的旧式风格的迭代器。
调用“forEach”方法，将某个函数应用于每个元素：
- 在并行流上，forEach会以任意顺序遍历各个元索；
- 如果想要按照流中的顺序来处理它们，可以调用“forEachOrdered”方法（会丧失并行处理的部分甚至全部优势）；
```
stream.forEach(System.out::println);
```

收集元素到集合

“stream.toArray()”：收集到数组中：

（如果想要让数组具有正确的类型，可以将其传递到数组构造器中）

// 1、“stream.toArray()”：会返回一个Object[]数组；
String[] result = stream.toArray()；

// 2、使用构造器，使数组有正确的类型
String[] result = stream.toArray(String[]::new);   // stream.toArray() has type Object[]

“stream.collect()”：收集到其他目标中；
- 该方法接受—个“Collector”接口的实例（Collectors类提供了大扯用于生成公共收集器的工厂方法）；
1. 收集到列表或集：
  List<String> resu1t = stream.co11ect(Co11ectors, toList()); 或 Set<String> result = stream.collect(Collectors.toSet());
2. 控制获得的集的种类：
  TreeSet<String> result = stream.collect(Co11ectors.toCo11ection(TreeSet::new)) ;
3. 通过连接操作来收集流中的所有字符串：
  String result= stream.collect(Collectors.joining());
4. 在元素之间增加分隔符，可以将分隔符传递给joining 方法：
  String result= stream.collect(Collectors.joining(", "));
5. 如果流中包含除字符串以外的其他对象，那么我们需要现将其转换为字符串：
  String result = stream.map(Object::toString).collect(Collectors.joining(", "));
6. 如果想要将流的结果约简为总和、平均值、最大值或最小值，可以使用“summarizing(IntlLonglDouble)”方法中的某一个。
  - （这些方法会接受一个将流对象映射为数据的函数，同时，这些方法会产生类型为“(Int|Long|Double)SummaryStatistics”的结果，同时计算总和、数最、平均值、最小值和最大值。）
  IntSummaryStatistics summary = stream.co11ect(Co11ectors.summarizingInt(String::length)); double averageWordLength = summary.getAverage(); double maxWordLength = summary.getMax();

收集到映射表中

“Collectors.toMap”方法有两个函数引元，它们用来产生映射表的键和值。

Map<Integer, String> idToName = people.collect(Co11ectors.toMap(Person::getId, Person::getName));

通常情况下，值应该是实际的元索，因此第二个函数可以使用“Function.identity()”；
（“Function.identity()”：返回一个输出跟输入一样的Lambda表达式对象，等价于形如“t -> t”形式的Lambda表达式）
```
Map<Integer, String> idToPerson = peop1e.collect(Collectors.toMap(Person::getId, Function.identity()));
```

如果有多个元素具有相同的键，那么就会存在冲突，收集器将会抛出一个“IllegalStateException”对象。

可以通过提供第3 个函数引元来覆盖这种行为：

Stream<Locale> loca1es = Stream.of(Locale.getAvailablelocales());
Map<String, String> languageNames = locales.collect(
   Co11ectors.toMap(
      Loca1e::getDisplaylanguage,
      l -> l.getDisplaylanguage(l),
      (existingValue, newValue) -> existingValue));

如果想要得到TreeMap, 那么可以将构造器作为第4 个引元来提供（合并函数）：

Map<lnteger, Person> idToPerson = people.collect(
   Co11ectors.toMap(
      Person::getld ,
      Function.identity(),
      (existingValue, newValue) -> { throw new IllegalStateException(); },
      TreeMap::new));

对于每一个toMap 方法，都有一个等价的可以产生并发映射表的“toConcurrentMap”方法。
- 单个并发映射表可以用于并行集合处理。
- 当使用并行流时，共享的映射表比合并映射表要更高效。
注意，元素不再是按照流中的顺序收集的，但是通常这不会有什么问题。

群组和分区

“groupingBy”方法，将具有相同特性的值群聚成组；（群组）

Map<String, List<Locale>> countryTolocales = 1oca1es.collect(Co11ectors.groupingBy(loca1e::getCountry));

“partitioningBy”方法；（分区）
当分类函数是断言函数（即返回boolean 值的函数）时，流的元素可以分区为两个列表：该函数返回true 的元素和其他的元素。在这种情况下，使用 partitioningBy 比使用 groupingBy 要更高效。
```
Map<Boolean, List<locale>> englishAndOtherlocales = locales.collect(Collectors.partitioningBy(l -> l.getlanguage().equals("en")));
List<locale> englishloca1es = englishAndOtherlocales.get(true);
```

如果调用groupingByConcurrent 方法，就会在使用并行流时获得一个被并行组装的并行映射表。这与toConcurrentMap 方法完全类似。

下游收集器

【？？？】 groupingBy 方法会产生一个映射表，它的每个值都是一个列表。如果想要以某种方式来处理这些列表，就需要提供一个“下游收集器”。
例如，如果想耍获得集而不是列表，那么可以使用上一节中看到的“Collector.toSet”收集器：

Map<String, Set<Locale>> countrylolocaleSet = locales.collect(
   groupingBy(Locale::getCountry, toSet()));

Java 提供了多种可以将群组元素约简为数字的收集器：（方法均为“java.util.stream.Collectors.xxx”）

“counting”会产生收集到的元素的个数：

Map<String, Long> countryToLocaleCounts = locales.co11ect(
   groupingBy(Locale::get(ountry, counting()));
// 可以对每个国家有多少个Locale 进行计数。

“summing(Int|Long|Double)”会接受一个函数作为引元，将该函数应用到下游元素中，并产生它们的和：

Map<String, Integer> stateToCityPopulation = cities.collect(
   groupingBy(City::getState, summingInt(City::getPopulation)));
// 可以计算城市流中每个州的人口总和。

“maxBy”和“minBy”会接受一个比较器，并产生下游元素中的最大值和最小值。例如：

Map<String, Optional<City>> statelolargestCity = cities.co11ect(
   groupingBy(City::getState, maxBy(Comparator.comparing(City::getPopulation))));
// 可以产生每个州中撮大的城市。

“mapping”方法会产生将函数应用到下游结果上的收集器，并将函数值传递给另一个收集器：

Map<String, Optional<String>> stateTolongestCityName = cities.collect(
   groupingBy(City::getState,
      mapping(City::getName,
         maxBy(Comparator.comparing(String::1ength)))));

将收集器组合起来是一种很强大的方式，但是它也可能会导致产生非常复杂的表达式。
它们的最佳用法是与groupingBy 和partitioningBy 一起处理”下游的＂映射表中的值。

否则，应该直接在流上应用诸如map 、reduce 、c ount 、max 或min 这样的方法。

其他

约简操作

“reduce”方法：是一种用于从流中计算某个值的通用机制，其最简单的形式将接受一个二元函数，并从前两个元素开始待续应用它。
- 如果reduce 方法有一项约简操作op，那么该约简就会产生“v0 op v1 op v2 op ...”，其中我们将函数调用“op(vi，vi+1)”写作“vi op vi+1”。
- 操作应该是可结合的：即组合元素时使用的顺序不应该成为问题【在数学标记法中，(x op y) op z 必须等于 x op (y op z)。即：操作顺序可变，但元素顺序不可变】。这使得在使用并行流时，可以执行高效的约简。
- 减法是一个不可结合操作的例子，例如，(6-3)-2 != 6-(3-2) 。
```
List<lnteger> values = ... ;
Optional<lnteger> sum = values.stream().reduce((x, y) -> x + y);   // 或“reduce(Integer::sum)”
```
通常，会有一个幺元值“e”：使得“e op x = x”，可以使用这个元素作为计算的起点：
- 如果流为空，则会返回么元值，就再也不需要处理Optional 类了。
```
List<lnteger> values= ... ;
Integer sum = values.stream().reduce(O, (x, y) -> x + y);   // Computes O + vo + v1 + v2 + . . .
```
对于引元和结果的类型相同的函数：需要提供一种“累积器”函数（如：“(total, word) -> total + word.length()”），这个函数会被反复调用，产生累积的总和。
- 但是，当计算被并行化时，会有多个这种类型的计算，需要将它们的结果合并。（因此需要提供第二个函数“组合器”来执行此处理）
```
int result = words.reduce(O,
   (total, word) -> tota1 + word.length(),
   (total1, total2) -> totall + total2);
```
实践中，可能并不会频繁地用到reduce 方法。通常，映射为数字流并使用其方法来计算总和、最大值和最小值会更容易：
- 因为它不涉及装箱操作，所以更简单也更高效；
```
words.mapToInt(String::length).sum(),
```
有时reduce 会显得并不够通用，而应使用“collect”方法：
- 它会接受单个引元：
  1. 一个提供者，它会创建目标类型的新实例，例如散列集的构造器。
  2. 一个累积器，它会将一个元素添加到一个实例上，例如add 方法。
  3. 一个组合器，它会将两个实例合并成一个，例如addAll。
```
BitSet result = stream.co11ect(BitSet::new, BitSet::set, BitSet::or);
```

基本类型流

基本类型流：

IntStream 、LongStream 和DoubleStream，用来直接存储基本类型值，而无需使用包装器；
存储short 、char 、byte 和boolean，可以使用IntStream；
对于float，可以使用DoubleStream。

基本类型流的使用：

创建IntStream，可以使用“IntStream.of”和“Arrays.stream”；

IntStream stream = IntStream.of(l, 1, 2, 3, 5);
stream = Arrays.stream(values, from, to);   // values is an int[] array

与对象流一样，我们还可以使用静态的“generate”和“iterate”方法；

IntStream和LongStream 有静态方法“range”和“rangeClosed”，可以生成步长为1 的整数范闱：

IntStream zeroToNinetyNine = IntStream.range(O, 100);   // Upper bound is excluded
IntStream zeroToHundred = IntStream.rangeClosed(0, 100);   // Upper bound is included

CharSequence 接口拥有“codePoints”和“chars”方法，可以生成由字符的Unicode码或由UTF-16编码机制的码元构成的IntStream：

String sentence = "\uD83S\u0D46 is the set of octonions.";   // \uD835\uDD46 is the UTF-16 encoding of the letter@, unicode U+1D546
IntStream codes = sentence.codePoints();   // The stream with hex values 1D546 20 69 73 20 . . .

基本流类型的转换：

将“对象流”转换为“基本类型流”：可以用“mapToInt”、“mapToLong”和“mapToDouble”方法；
```
Stream<String> words = . . . ;
lntStream lengths = words.mapToInt(String::length);
```
将“基本类型流”转换为“对象流”：需要用“boxed”方法；
```
Stream<lnteger> integers = IntStream.range(O, 100).boxed();
```

“基本类型流”与“对象流”的方法类似，但有差异：

toArray 方法会返回基本类型数组。
产生可选结果的方法会返回一个OptionalInt 、OptionalLong 或OptionalDouble。
这些类与Optional 类类似，但是具有getAslnt 、getAslong 和getAsDouble 方法，而不是get 方法。
具有返回总和、平均值、最大值和最小值的sum 、average 、max 和min 方法。对象流没有定义这些方法。
summaryStatisties 方法会产生一个类型为IntSummaryStatistics 、LongSummaryStatistics 或DoubleSummaryStatistics 的对象，它们可以同时报告流的总和、平均值、最大值和最小值。

并行流

并行流的获取：

用“Collection.parallelStream()”方法从任何集合中获取一个并行流：
```
Stream<String> parallelWords = words.parallelStream();
```

“parallel”方法可以将任意的顺序流转换为并行流：

Stream<String> parallelWords = Stream.of(wordArray).parallel();

只要在终结方法执行时，流处于并行模式，那么所有的中间流操作都将被并行化。
当流操作并行运行时，这些操作必须可以以任意顺序执行，才能使其返回结果与顺序执行时返回的结果相同。

并行流的使用：【Fork-Join框架】

传递给并行流操作的函数不应该被堵寒：
   并行流使用fork-join 池来操作流的各个部分。如果多个流操作被阻塞，那么池可能就无法做任何事情了。

int[] shortWords = new int[12];
words.para11e1Stream().forEach(
   s -> { if (s.length() < 12) shortWords[s.length()]++; });   // Error-race condition!
System.out.print1n(Arrays.toString(shortWords));
// 这是一种非常非常糟糕的代码。传递给forEach 的函数会在多个并发线程中运行，每个都会更新共享的数组。
// 如果多次运行这个程序，很可能出现每次运行都会产生不同的计数值，而且每个都是错的。

// 可以使用以下方法：
Map<lnteger, long> shortWordCounts =
   words.parallelStream()
      .filter(s -> s.length() < 10)
      .co11ect(groupingBy(
         String::length,
         counting()));

默认情况下，从有序集合（数组和列表）、范围、生成器和迭代产生的流，或者通过调用Stream.sorted 产生的流，都是有序的。
它们的结果是按照原来元素的顺序累积的，因此是完全可预知的。如果运行相同的操作两次，将会得到完全相同的结果。
当放弃排序需求时（在流上调用“unordered”方法），有些操作可以被更有效地并行化。
在有序的流中，“distinct”会保留所有相同元素中的第一个，这对并行化是一种阻碍，因为处理每个部分的线程在其之前的所有部分都被处理完之前，并不知道应该丢弃哪些元素。

合并映射表的代价很高昂。正是因为这个原因，“Collectors.groupByConcurrent”方法使用了共享的并发映射表。为了从并行化中获益，映射表中值的顺序不会与流中的顺序相同。

Map<lnteger, List<Stri ng>> result = words.paral1e1Stream().collect(
   Col1ectors.groupingByConcurrent(String::1ength));
// Values aren't collected in stream order

当然，如果使用独立于排序的下游收集器，那么就不必在意了：

Map<Integer, Long> wordCounts =
   words.parallelStream()
      .collect(
         groupingByConcurrent(
            String::length,
            counting())) ;

关于并行流的修改：
# 流并不会收集它们的数据，数据总是在单独的集合中。
# 不要修改在执行某项流操作后会将元素返回到流中的集合（即使这种修改是线程安全的）。
# 因为中间的流操作都是惰性的，所以直到执行终结操作时才对集合进行修改仍旧是可行的。

// 不推荐的代码
List<String> wordList = ...;
Stream<String> words = wordlist.stream();
wordlist.add("END");
long n = words.distinct().count();

// 错误的代码
Stream<String> words = wordlist.stream();
words.forEach(s -> if(s.length() < 12) wordlist.remove(s));   // Error-interference，不能再流中修改集合

不要将所有的流都转换为并行流。只有在对已经位于内存中的数据执行大量计算操作时，才应该使用并行流。

为了让并行流正常工作，需要满足大批的条件：

数据应该在内存中。
必须等到数据到达是非常低效的。
流应该可以被高效地分成若干个子部分。
由数组或平衡二叉树支撑的流都可以工作得很好，但是Stream.iterate返回的结果不行。
流操作的工作盐应该具有较大的规模。
如果总工作负载并不是很大，那么搭建并行计算时所付出的代价就没有什么意义。
流操作不应该被阻塞。

@@ 第786行： / 第786行： @@
-并行流的使用：【[[Fork-Join框架]]】
+并行流的使用：<big>【'''[[Fork-Join框架]]'''】</big>
 <pre>
 传递给并行流操作的函数不应该被堵寒：
-    并行流使用fork-joi n 池来操作流的各个部分。如果多个流操作被阻塞，那么池可能就无法做任何事情了。
+    并行流使用fork-join 池来操作流的各个部分。如果多个流操作被阻塞，那么池可能就无法做任何事情了。
 </pre>
 <syntaxhighlight lang="java">

“核心技术Ⅱ：流”的版本间差异

2020年11月24日 (二) 05:57的版本

关于 Java SE 8 的流库

从迭代到流的操作

流与集合

相关方法

流的创建

相关方法

流的转换

filter 、map 和 flatMap 方法

相关方法

抽取子流和连接流

相关方法

其他的流转换

相关方法

流的终止操作

简单约简

Optional 类型

如何使用Optional值

相关方法

不适合使用Optional值的方式

相关方法

创建Optional 值

相关方法

用flatMap 来构建Optional值的函数

相关方法

收集结果

查看元素

相关方法

收集元素到集合

相关方法

收集到映射表中

相关方法

群组和分区

相关方法

下游收集器

相关方法

其他

约简操作

相关方法

基本类型流

相关方法

并行流

导航菜单

搜索