Java8: Stream API_java8 stream api

一、Stream概述

Stream是对容器对象功能的增强,它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来拆分任务和加速处理过程。

Stream就如同一个更高级的迭代器（Iterator），单向，不可往复，数据只能遍历一次，就像流水一样从面前流过。和迭代器又不同的是，Stream可以并行化操作，迭代器只能串行化操作。顾名思义，当使用串行方式去遍历时，每个item读完后再读下一个item。而使用并行去遍历时，数据会被分成多个段，其中每一个都在不同的线程中处理，然后将结果一起输出。

二、流的基本使用

1、流的构造与转换

（1）流的构造

// 1. Individual values
Stream stream = Stream.of("a", "b", "c");

// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);

// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();
1
2
3
4
5
6
7
8
9
10
11

注意：
对于基本数值型，目前有三种对应的包装类型Stream：IntStream、LongStream、DoubleStream

IntStream.of(new int[]{1, 2, 3}).forEach(System.out::println);
IntStream.range(1, 3).forEach(System.out::println);
1
2

（2）流的转换

// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();
1
2
3
4
5
6
7
8
9

2、流的操作

- 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

（1）map/flatMapy：

map生成的是个1:1映射，每个输入元素都按照规则转换成为另外一个元素。

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

flatMap处理一对多映射关系，flatMap把inputStream中的层级结构“扁平化”，就是将最底层元素抽出来放到一起，最终output的新Stream里面已经没有List了，都是直接的数字。

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());
1
2
3
4
5
6
7

（2）filter

filter对原始Stream进行某项测试，通过测试的元素被留下来生成一个新Stream。

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

（3）forEach

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

// 对一个人员集合遍历，找出男性并打印姓名。
roster.stream().filter(p -> p.getGender() == Person.Sex.MALE)
.forEach(p -> System.out.println(p.getName()));
1
2
3

注意：

• 当需要为多核系统优化时，可以parallelStream().forEach()，只是此时原有元素的次序没法保证
• forEach不能用break/return之类的关键字提前结束循环

（4）findFirst

返回Stream的第一个元素或者空。它的返回值类型为Optional，返回值可能含有某值，或者不包含,使用它的目的是尽可能避免NullPointerException。

注意：

• Stream中的findAny、max/min、reduce等方法也返回Optional值
• findAny和findFirst类似，只不过findAny为并行查找，返回的元素可能不是第一个出现的元素。

（5）reduce

这个方法的主要作用是把Stream元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面Stream的第一个、第二个、第n个元素组合。从这个意义上说，字符串拼接、数值的 sum、min、max、average都是特殊的reduce。

例如Stream的sum就相当于：

Integer sum = integers.reduce(0, (a, b) -> a+b);
1

有起始值的 reduce() 都返回具体的对象。而对于最后一个示例，没有起始值的 reduce()，返回的是 Optional，

// 字符串连接，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);

// 过滤，字符串连接，concat = "ace"
concat = Stream.of("a", "B", "c", "D", "e", "F").
 filter(x -> x.compareTo("Z") > 0).
 reduce("", String::concat);

// 求和，sumValue = 10, 无起始值，
// 使用get()获取Optional中的对象
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

（6）limit/skip

limit返回Stream的前面n个元素；skip则是扔掉前n个元素

 List<Person> persons = new ArrayList();
 for (int i = 1; i <= 10000; i++) {
 Person person = new Person(i, "name" + i);
 persons.add(person);
 }
List<String> personList = persons.stream().
map(Person::getName).limit(10).skip(3).collect(Collectors.toList());
 System.out.println(personList);

//[name4, name5, name6, name7, name8, name9, name10]
1
2
3
4
5
6
7
8
9
10

（7）sorted

对Stream的排序通过sorted进行，它比数组的排序更强之处在于你可以首先对Stream进行各类map、filter、limit、skip甚至distinct来减少元素数量后再排序，这能帮助程序明显缩短执行时间。

// 优化：排序前进行 limit 和 skip
List<Person> persons = new ArrayList();
 for (int i = 1; i <= 5; i++) {
 Person person = new Person(i, "name" + i);
 persons.add(person);
 }

List<Person> personList2 = persons.stream().limit(2).sorted((p1, p2) -> p1.getName().compareTo(p2.getName())).collect(Collectors.toList());
System.out.println(personList2);
1
2
3
4
5
6
7
8
9

注意：
不要排序后再取值

（8）min和max

min和max的功能也可以通过对Stream元素先排序，再findFirst来实现，但前者的性能会更好为O(n)，而sorted的成本是O(nlogn)。同时它们作为特殊的reduce方法被独立出来也是因为求最大最小值是很常见的操作。

// 找出最长一行的长度
BufferedReader br = new BufferedReader(new FileReader("c:\\SUService.log"));
int longest = br.lines().mapToInt(String::length).max().getAsInt();
br.close();
System.out.println(longest);
1
2
3
4
5

（9）distinct

使用distinct来找出不重复的单词。

// 找出全文的单词，转小写，并排序
List<String> words = br.lines().flatMap(line -> Stream.of(line.split(" "))).
 filter(word -> word.length() > 0).map(String::toLowerCase).distinct().sorted()
 .collect(Collectors.toList());
br.close();
System.out.println(words);
1
2
3
4
5
6

（10）Match

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

// 使用 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

注意：
所有Stream的操作必须以lambda表达式为参数

参考文章：
[1] Java8中的Stream API详解:Stream的背景及使用