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

2020年11月23日 (一) 02:13的版本

关于 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 方法完全类似。

其他

约简操作

基本类型流

并行流

@@ 第547行： / 第547行： @@
 == 其他 ==
-=== 下游收集器 ===
 === 约简操作 ===
 === 基本类型流 ===
 === 并行流 ===

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

2020年11月23日 (一) 02:13的版本

关于 Java SE 8 的流库

从迭代到流的操作

流与集合

相关方法

流的创建

相关方法

流的转换

filter 、map 和 flatMap 方法

相关方法

抽取子流和连接流

相关方法

其他的流转换

相关方法

流的终止操作

简单约简

Optional 类型

如何使用Optional值

相关方法

不适合使用Optional值的方式

相关方法

创建Optional 值

相关方法

用flatMap 来构建Optional值的函数

相关方法

收集结果

查看元素

相关方法

收集元素到集合

相关方法

收集到映射表中

相关方法

群组和分区

相关方法

其他

约简操作

基本类型流

并行流

导航菜单

搜索