Java8新特性 stream流

stream API

简单介绍

stream作为Java8的一大亮点,能够极大地提高编程效率和程序的可读性,很方便的写出高性能的并发程序.

stream是对集合(Collection)操作的功能集成,它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。

stream流详解

stream流是什么

stream流不是集合也不保存数据,它更像是一个高级的Iterator,当用户提出什么要求时,在内部进行便利对集合做出相应的转变.

流有两种操作类型:
Intermediate: 流的后面可以加Intermediate操作,对集合进行某种聚合.然后返回一个新的流进行下一步操作.这种类型还没有开始真正的遍历!
Terminal:Terminal是流的最后一个操作,之后误发再次被使用.进行Terminal操作才会进行真正的遍历,并返回一个结果.

流的构造和转换

流的常见构造方法

//1.values
Stream stream = Stream.of("a","b","c");
//2. Arrays
String[] arrays = String[]{"a","b","c"};
stream = Stream.of(arrays);
stream = Arrays.stream(arrays);
//3. Collections
List<String> list = Arrays.asList(arrays);
stream = list.stream();

流的常见转换

//1.Arrays
String[] array = stream.toArray(String::new);
//2.Collections
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set = stream.collect(Collectors.toSet());
Stack stack = stream.collect(Collectors.toCollection(Stack::new));
//3. String
String str = stream.collect(Collectors.joining()).toString();

流的操作

Map/flatMap
Map是一对一把一个元素映射成另外一个元素
而flatMap是一对多的映射关系

//Map 转换大写
List<String> upWords = words.stream()
.map(String::toUpperCase).collect(Collectors.toList());
//Map 平方
List<Integer> nums = Arrays.asList(1, 2, 3, 4);
List<Integer> squarrNums = nums.stream()
.map(n -> n * n)..collect(Collectors.toList());
//flatMap 一对多
Stream<List<Integer>> inputStream = Stream.of(
 Arrays.asList(1),
 Arrays.asList(2, 3),
 Arrays.asList(4, 5, 6)
 );
Stream<Integer> outputStream = inputStream.stream()
.flatMap((childList) -> childList.stream());

filter
过滤掉不符合要求的元素 留下符合要求的元素生成新的流

//留下能被2整除的 
Integer[] sixNums = {1, 2, 3, 4, 5, 6};
Integer[] evens = Stream.of(sixNums ).
filter(o -> o%2 == 0).toArray(Integer::new);
//留下一篇文章的单词
List<String> output = reader.lines()
 .flatMap(line -> Stream.of(line.split(REGEXP)))
 .filter(word -> word.length() > 0)
 .collect(Collectors.toList());

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

//打印男性的名字
people.stream()
.filter(p -> p.getGender == Person.Sex.Male)
.forEach(p -> System.out.println(p.getName()));

forEach 是terminal 操作,被操作后流就没有了,不能再使用.所以不能对同一个流进行两次forEach操作
So peek(intermediate )就可以达到目的
peek对每个元素执行表达式后 返回一个新的stream流

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

reduce
主要作用是把 Stream 元素组合起来.字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。

//字符串拼接
String concat = Steram.of("A","B","C","D").reduce("", String::concat);
//求最小值
double minV = Stream.of(1,33,0.5,-0.4).reduce(Double.MAX_VALUE, Double::min);
//求和
int sumV = Stream.of(1,5,66,0.1).reduce(0, Integer::sum);
sumV = Stream.of(1,5,66,0.1).reduce(Integer::sum).get();

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

List<String> personsName = persons.stream()
.map(Person::getName).limit(10).skip(2)
.collect(Collectors.toList());

sorted
Stream 的排序，你可以首先对 Stream 进行 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间.(不要求排序后再取值。)

List<Person> personsList = persons.stream().limit(2)
.sort((p1,p2) -> p1.getName.compareTo(p2.getName))
.collect(Collectors.toList());

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

BufferedReader br = new BufferedReader(new FileReader("c:\\SUService.log"));
//最長一行
int longest = br.lines().mapToInt(String::length)
.max(). getAsInt();
//全文不重复单词 转小写 排序
List<String> words = br.lines().
 flatMap(line -> Stream.of(line.split(" "))).
 filter(word -> word.length() > 0).
 map(String::toLowerCase).
 distinct().
 sorted().
 collect(Collectors.toList());

Match
Stream 有三个 match 方法，从语义上说：
allMatch：Stream 中全部元素符合传入的 predicate，返回 true
anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true
它们都不是要遍历全部元素才能返回结果。例如 allMatch 只要一个元素不满足条件，就 skip 剩下的所有元素，返回 false。对清单 13 中的 Person 类稍做修改，加入一个 age 属性和 getAge 方法。

boolean isAllAdult = persons.stream().
 allMatch(p -> p.getAge() > 18);
boolean isThereAnyChild = persons.stream().
 anyMatch(p -> p.getAge() < 12);