jdk8 stream

获取一个数据源（source）→ 数据转换→执行操做获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（能够有屡次转换），这就容许对其操做能够像链条同样排列，变成一个管道，

Stream操做还有两个基础的特征：

• Pipelining: 中间操做都会返回流对象自己。 这样多个操做能够串联成一个管道， 如同流式风格（fluent style）。 这样作能够对操做进行优化， 好比延迟执行(laziness)和短路( short-circuiting)。
• 内部迭代： 之前对集合遍历都是经过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫作外部迭代。 Stream提供了内部迭代的方式， 经过访问者模式(Visitor)实现。

     

对 Stream 的使用就是实现一个 filter-map-reduce 过程，产生一个最终结果，或者致使一个反作用（side effect）。

流的操做

接下来，当把一个数据结构包装成 Stream 后，就要开始对里面的元素进行各种操做了。常见的操做能够归类以下。

• Intermediate：

map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered

• Terminal：

forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

• Short-circuiting：

anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

一对多 及 flatmap

Stream<List<Integer>> inputStream = Stream.of(
 Arrays.asList(1),
 Arrays.asList(2, 3),
 Arrays.asList(4, 5, 6)
 );
Stream<Integer> outputStream = inputStream.
flatMap((childList) -> childList.stream());

flatMap 把 input Stream 中的层级结构扁平化，就是将最底层元素抽出来放到一块儿，最终 output 的新 Stream 里面已经没有 List 了，都是直接的数字。

例 ： 把单词挑出来

List<String> output = reader.lines().
 flatMap(line -> Stream.of(line.split(REGEXP))).
 filter(word -> word.length() > 0).
 collect(Collectors.toList());

这段代码首先把每行的单词用 flatMap 整理到新的 Stream，而后保留长度不为 0 的，就是整篇文章中的所有单词了。

forEach

forEach 方法接收一个 Lambda 表达式，而后在 Stream 的每个元素上执行该表达式。

清单 12. 打印姓名（forEach 和 pre-java8 的对比）

// Java 8
roster.stream()
 .filter(p -> p.getGender() == Person.Sex.MALE)
 .forEach(p -> System.out.println(p.getName()));
// Pre-Java 8
for (Person p : roster) {
 if (p.getGender() == Person.Sex.MALE) {
 System.out.println(p.getName());
 }
}

须要注意，forEach 是 terminal 操做，所以它执行后，Stream 的元素就被“消费”掉了，你没法对一个 Stream 进行两次 terminal 运算。forEach 不能修改本身包含的本地变量值，也不能用 break/return 之类的关键字提早结束循环。

reduce

这个方法的主要做用是把 Stream 元素组合起来。它提供一个起始值（种子），而后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。

// 字符串链接，concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); 
// 求最小值，minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min); 
// 求和，sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和，sumValue = 10, 无起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
// 过滤，字符串链接，concat = "ace"
concat = Stream.of("a", "B", "c", "D", "e", "F").
 filter(x -> x.compareTo("Z") > 0).
 reduce("", String::concat);

　　上面代码例如第一个示例的 reduce()，第一个参数（空白字符）即为起始值，第二个参数（String::concat）为 BinaryOperator。这类有起始值的 reduce() 都返回具体的对象。而对于第四个示例没有起始值的 reduce()，因为可能没有足够的元素，返回的是 Optional，请留意这个区别。

 

min/max/distinct

min 和 max 的功能也能够经过对 Stream 元素先排序，再 findFirst 来实现，但前者的性能会更好，为 O(n)，而 sorted 的成本是 O(n log n)。

Match

Stream 有三个 match 方法，从语义上说：

• allMatch：Stream 中所有元素符合传入的 predicate，返回 true
• anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
• noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

它们都不是要遍历所有元素才能返回结果。例如 allMatch 只要一个元素不知足条件，就 skip 剩下的全部元素，返回 false。对清单 13 中的 Person 类稍作修改，加入一个 age 属性和 getAge 方法。

使用 Match

List<Person> persons = new ArrayList();
persons.add(new Person(1, "name" + 1, 10));
persons.add(new Person(2, "name" + 2, 21));
persons.add(new Person(3, "name" + 3, 34));
persons.add(new Person(4, "name" + 4, 6));
persons.add(new Person(5, "name" + 5, 55));
boolean isAllAdult = persons.stream().
 allMatch(p -> p.getAge() > 18);
System.out.println("All are adult? " + isAllAdult);
boolean isThereAnyChild = persons.stream().
 anyMatch(p -> p.getAge() < 12);
System.out.println("Any child? " + isThereAnyChild);
输出结果：

All are adult? false

Any child? true

 

Collectors

Collectors 类实现了不少归约操做，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：

  List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); 

List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList()); 
System.out.println("筛选列表: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);

Stream 的特性能够概括为：

• 不是数据结构

• 它没有内部存储，它只是用操做管道从 source（数据结构、数组、generator function、IO channel）抓取数据。
• 它也毫不修改本身所封装的底层数据结构的数据。例如 Stream 的 filter 操做会产生一个不包含被过滤元素的新 Stream，而不是从 source 删除那些元素。

• 全部 Stream 的操做必须以 lambda 表达式为参数
• 不支持索引访问

• 你能够请求第一个元素，但没法请求第二个，第三个，或最后一个。不过请参阅下一项。

• 很容易生成数组或者 List
• 惰性化

• 不少 Stream 操做是向后延迟的，一直到它弄清楚了最后须要多少数据才会开始。
• Intermediate 操做永远是惰性化的。

• 并行能力

• 当一个 Stream 是并行化的，就不须要再写多线程代码，全部对它的操做会自动并行进行的。

• 能够是无限的
  • 集合有固定大小，Stream 则没必要。limit(n) 和 findFirst() 这类的 short-circuiting 操做能够对无限的 Stream 进行运算并很快完成。

 

本文转自：https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/index.html