Java8 Stream 常用API详解

Java8 添加了一个新的抽象称为流 Stream，可以以一种声明的方式处理数据。Stream 不是集合元素，不是数据结构因此不能保存数据，是有关算法和计算的，更像一个高级版本的 Iterator。原始版本的 Iterator 只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream 只需给出需要对其包含的元素执行什么操作（过滤长度>10的字符串，获取每个字符串的首字母等），Stream 会隐式地在内部进行遍历，做出相应的数据转换。

Java8 添加了一个新的抽象称为流 Stream，可以以一种声明的方式处理数据。如

List transactionsIds = widgets.stream()             .filter(b -> b.getColor() == RED)             .sorted((x,y) -> x.getWeight() - y.getWeight())             .mapToInt(Widget::getWeight)             .sum();

Stream 不是集合元素，不是数据结构因此不能保存数据，是有关算法和计算的，更像一个高级版本的 Iterator。原始版本的 Iterator 只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream 只需给出需要对其包含的元素执行什么操作（过滤长度>10 的字符串，获取每个字符串的首字母等），Stream 会隐式地在内部进行遍历，做出相应的数据转换。

流的构成

使用一个流的时候，通常包括三个基本步骤，获取数据源（source）-> 数据转换 -> 执行操作获取结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象

生成 Stream Source

常用的创建流的方式如下，

数组

可以使用 Arrays.stream()或者 stream.of()

String[] arr = new String[]{"cat", "dog", "fish"};Stream stream = Arrays.stream(arr);stream = Stream.of("cat", "dog", "fish");

of()方法内部其实调用了 Arrays.stream()

集合

可以直接使用 stream()或者使用 parallelStream()方法创建并发流，默认使用的是 ForkJoinPool.commonPool()线程池

List list = new ArrayList();list.add("cat");list.add("dog");list.add("fish");stream = list.stream();List aList = new ArrayList();Stream parallelStream = aList.parallelStream();

操作流

流的操作类型分为两种：

1. Intermediate：一个流可以后面跟随 0 个或多个 intermediate 操作，其目的主要是打开流，然后进行数据过滤、映射等操作，然后返回一个新的流，交给下一个操作使用，这类操作是惰性化的，就是说，仅仅调用到这类方法，并没有真正开始流的遍历。

2. Terminal：一个流只能有一个 terminal 操作，当这个操作执行后，流就被使用“光”了，无法再被操作，termial 操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个副作用（side effect）。

3. short-circuiting：

   • 对于一个 intermediate 操作，如果它接受一个无限大（infinite/unbounded）的 Stream，但返回一个有限的新 Stream
   • 对于一个 terminal 操作，如果它接受的是一个无限大的 Stream，但能在有限的时间计算出结果

流的操作

常见操作归类如下：

1. Intermediatemap（mapToInt、flatMap 等）、filter、distinct、sorted、peek、limit、skip、parallel、sequential、unordered

2. TerminalforEach、forEachOrdered、toArray、reduce、collect、min、max、count、anyMatch、allMatch、noneMatch、findFirst、findAny、iterator

3. Short-circuitinganyMatch、allMatch、noneMatch、findFirst、findAny、limit

转换流

既然可以把集合或者数组转换成流，也就可以把流转换回去，使用 collect()可以把流转换回去

Collectors 是一个收集器的工具类，内置了一系列收集器实现

• toList()方法将元素收集到一个新的 java.util.List
• toCollection()将元素收集到一个新的 java.util.ArrayList
• joining()将元素收集到一个可以用分隔符指定的字符串中

常用操作

1. map，把 input Stream 的每一个元素映射成 output Stream 的另外一个元素，是 1:1 映射，如果要一对多映射，则需要使用 flatMap

转换大写

List output = wordList.stream()    .map(String::toUpperCase)    .collect(Collectors.toList());

平方数

List nums = Arrays.asList(1, 2, 3, 4);List squareNums = nums.stream()    .map(n -> n * n)    .collect(Collectors.toList());

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

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

3. filter 对原始 Stream 进行某种过滤，通过过滤的元素被留下来生成一个新 Stream

经过“被 2 整除”的 filter，剩下数字为{2, 4, 6}

Integer[] sixNums = {1, 2, 3, 4, 5, 6};Integer[] evens = Stream.of(sixNums).filter(n -> n%2 == 0).toArray(Interger[]::new);

首先把每行的单词用 flatMap 整理到新的 Stream，然后留下长度>0 的，就是本篇文章中的全部单词了

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

4. forEach 接收一个 Lambda 表达式，然后在 Stream 的每一个元素上执行该表达式

打印姓名

roster.stream()    .filter(p -> p.getGender() == Person.Sex.MALE)    .forEach(p -> System.out.println(p.getName()));

当需要为多核系统优化时，可以使用 parallelStream().forEach()，只是此时原有元素的次序没法保证，并行的情况下将改变串行时操作的行为

注意

• forEacch 和常规 for 循环的差异不涉及性能，仅仅是函数式风格与传统 Java 风格的差别
• forEach 是 terminal 操作，因此它执行后，Stream 的元素就被“消费”掉了，无法对一个 Stream 进行两次 terminal 操作，具有相似功能的 intermediate 操作 peek 可以进行多次操作
• forEach 不能修改自己包含的本地变量值，也不能用 break、return 之类的关键字提前结束循环

1. peek 对每个元素执行操作并返回一个新的 Stream

Stream.of("one", "two", "three", "four")    .filter(e -> e.length() > 3)    .peek(e -> System.out.println("filtered value is " + e))    .map(String::toUpperCase)    .peek(e -> System.out.println("Mapped value is " + e))    .collect(Collectors.toList());

6. findFirst 是一个 terminal 兼 short-circuiting 操作，它总是返回 Stream 的第一个元素或者空

注意返回值类型为 Optional，这也是一个模拟 Scala 语言中的概念，作为一个容器，它可能含有某值，或者不包含，使用它的目的是尽可能避免 NullPointerException

Optional 示例

// Java 8Optional.ofNullable(text).ifPresent(System.out.println);// Pre Java 8if (text != null) {    System.out.println(text);}// Java 8Optional.ofNullable(text).map(String::length).orElse(-1);// Pre Java 8return if (text != null) ? text.length() : -1;

在更复杂的 if(xx != null)的情况下，使用 Optional 代码的可读性更好，而且它提供编译时检查，能极大的降低 NPE 这种 Runtime Exception 对程序的影响

Stream 中的 findAny、max/min、reduce 等方法返回 Optional 值，还有例如 IntStream.average()返回 OptionalDouble 等

7. Reduce 主要作用是把 Stream 元素组合起来，它提供一个起始值，然后依照运算规则（BinaryOperator）和前面的第一个、第二个、第 n 个元素组合，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce

也有没有起始值的情况，这时会把 Stream 的前面两个元素组合起来，返回的是 Optional

// 字符串连接，concat = "ABCD"String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);// 求最小值，minValue = -3.0double 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，由于可能没有足够的元素，返回的是 Optional

8. limit/skip limit 返回 Stream 的前 n 个元素，skip 则是扔掉前 n 个元素（由 subStream 方法改名而来）

List personList = persons.stream()    .map(Person::getName)    .limit(10)    .skip(3)    .collect(Collectors.toList());

9. sorted 对 Stream 排序通过 sorted 进行，它比数组的排序更强之处在于可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序

List personList = persons    .stream()    .limit(2)    .sorted((p1, p2) -> p1.getName().compareTo(p2.getName()))    .collect(Collectors.toList());

10. min/max/distinct min 和 max 也可以通过 Stream 元素先排序，再 findFirst 来实现，但前者的性能会更好，为 O(n)，而 sorted 的成本是 O(n log n)

找出最长一行的长度

BufferedReader br = new BufferedReader(new FileReader("/tmp/info.log"));int longest = br.lines()    .mapToInt(String::length)    .max()    .getAsInt();br.close();

使用 distinct 找出不重复的单词

List words = br.lines()    .flatMap(line -> Stream.of(line.split(" ")))    .filter(word -> word.length() > 0)    .map(String::toLowerCase)    .distinct()    .sorted()    .collect(Collectors.toList());

11. MatchStream 有三个 match 方法

• anyMatch()，只要有一个元素匹配传入的条件，就返回 true
• allMatch()，只有有一个元素不匹配传入的条件，就返回 false；如果全部匹配，则返回 true。
• noneMatch()，只要有一个元素匹配传入的条件，就返回 false；如果全部匹配，则返回 true。

参考

https://mp.weixin.qq.com/s/7hNUjjmqKcHDtymsfG_Gtwhttps://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/index.html

阅读全文: http://gitbook.cn/gitchat/activity/5ea2ab0df132164fa808f9d5

您还可以下载 CSDN 旗下精品原创内容社区 GitChat App ，阅读更多 GitChat 专享技术内容哦。