JDK8 Stream 详细使用
JDK8 管道 Stream 详细使用介绍
Stream 的获取
① 通过集合Collection获取
List list = new ArrayList(Arrays.asList(1,2,3,4,5));
Stream stream = list.stream();
② 通过数组获取
String[] array = {"are","you","ok"};
Stream stream = Arrays.stream(array);
//对于基本类型数组的处理
int[] array = {1,2,3,4,5};
Stream stream = Arrays.stream(array).boxed();
//Arrays.stream(array)获取的是一个IntStream对象，boxed 方法用于将目前 Stream 中的基本类型装箱
③ 直接通过值获取
Stream stream = Stream.of("are","you","ok");
Stream 常用管道操作
1) 筛选 filter
filter函数接收一个Lambda表达式作为参数，该表达式返回 boolean，在执行过程中，流将元素逐一输送给filter，并筛选出执行结果为 true 的元素；
//筛选出列表中的非空项
List list = Arrays.asList("are","you","","ok");
List filted = list.stream()
.filter(x-> !x.empty())
.collect(Collectors.toList());
2) 去重 distinct
//去除列表中的重复元素
List list = Arrays.asList("are","you","you","ok");
List distincted = list.stream()
.distinct()
.collect(Collectors.toList());
3) 截取 limit
截取流的前N个元素：
//获取Stream的前3个值
List list = Arrays.asList("are","you","fucking","ok");
List distincted = list.stream()
.limit(3);
.collect(Collectors.toList());
4) 跳过 skip
跳过流的前n个元素：
List list = Arrays.asList("are","you","fucking","ok");
List distincted = list.stream()
.skip(2);
.collect(Collectors.toList());
5) 映射 map
对流中的每个元素执行一个函数，使得元素转换成另一种类型输出。流会将每一个元素输送给map函数，并执行map中的Lambda表达式，最后将执行结果存入一个新的流中。
如：将 list 中每一个 Integer类型元素自增后转化为 String类型
//将集合中的每一个元素+1，并转为字符串
List list = Arrays.asList(1,2,3,4,5);
List result = list.stream()
.map(x->String.valueOf(++x))
.collect(Collectors.toList());
//统计集合中>3的元素数量
int result = list.stream().filter(x -> x > 3).count();
6) 合并多个流 flatMap
List list1 = .....
List list2 = ...
List> list = Arrays.asList(list1,list2);
//将list中的list1，list2合并为一个List
List listsum = list.stream()
.flatMap(List::stream)
.collect(Collectors.toList());
以下一个实际的应用例子：列出 list 中各不相同的单词；
List list = new ArrayList();
list.add("I am a boy");
list.add("I love the girl");
list.add("But the girl loves another girl");
list.stream().map(line->line.split(" ")) //将每一个项分词，并映射为数组
.flatMap(Arrays::stream) //将每一个分项数组组合并到主流中，形成一个包含所有分项数组的总数组流
.distinct() //去重
.forEach(System.out::println); //打印
7）匹配元素
①是否匹配任一元素：anyMatch
anyMatch用于判断流中是否存在至少一个元素满足指定的条件，这个判断条件通过Lambda表达式传递给anyMatch，执行结果为boolean类型。
//判断流中是否含有>10的项
List list = Arrays.asList(1,2,3,4,5,6);
boolean result = list.stream()
.anyMatch(x->x>10);
② 是否匹配所有元素：allMatch
allMatch用于判断流中的所有元素是否都满足指定条件，这个判断条件通过Lambda表达式传递给anyMatch，执行结果为boolean类型。
//判断流中是否全部>5
List list = Arrays.asList(1,2,3,4,5,6);
boolean result = list.stream()
.allMatch(x->x>5);
③ 是否未匹配所有元素：noneMatch
noneMatch与allMatch恰恰相反，它用于判断流中的所有元素是否都不满足指定条件：
//判断流中是否 全部不满足 >5
List list = Arrays.asList(1,2,3,4,5,6);
boolean result = list.stream()
.noneMatch(x->x>5);
8）获取元素
①获取任一元素 ：findAny
findAny从流中随机选出 一个元素出来，它返回一个Optional类型的元素。
List list = Arrays.asList(1,2,3,4,5,6);
Optional result = list.stream().findAny();
if(result.isPresent())
Integer randValue = result.get();
//or:
Integer randValue = result.orElse(0);
//合并的调用方式
Integer randValue = list.stream().findAny().orElse(0);
② 获取第一个元素：findFirst
Optional result = list.stream().findFirst();
Optional 对象介绍
Optional是Java8新加入的一个容器，这个容器只存1个或0个元素，它用于防止出现NullpointException，它提供如下方法：
- isPresent()
判断容器中是否有值。 - ifPresent(Consume lambda)
容器若不为空则执行括号中的Lambda表达式。 - T get()
获取容器中的元素，若容器为空则抛出NoSuchElement异常。 - T orElse(T other)
获取容器中的元素，若容器为空则返回括号中的默认值。
9） 归约统计
归约是将集合中的所有元素经过指定运算，折叠成一个元素输出，如：求最值、平均数等，这些操作都是将一个集合的元素折叠成一个元素输出；
//获取一个整型列表的最大值，最小值
Random random = new Random();
List list = random.ints(1,100).limit(50).boxed().collect(Collectors.toCollection(ArrayList::new));
int max = list.stream().max(Integer::compare).orElse(-1); //获取最大值
int min = list.stream().min(Integer::compare).orElse(-1); //获取最小值
//获取一个Bean列表的最大值对象，最小值对象，使用自定义的 Comparator
List beans = new ArrayList<>();
for(int i = 0; i < 50; i++){
beans.add(new Bean(String.valueOf(random.nextInt(10000)),random.nextInt(20)));
}
Bean maxBean = beans.stream().max(Comparator.comparingInt(Bean::getOrderNum)).get();
Bean mixBean = beans.stream().min((bean1, bean2) ->{ //使用自定义的 lambda 表达式
if(bean1.getId() == null){
bean1.setOrderNum(0);
}
if(bean2.getId() == null){
bean2.setOrderNum(0);
}
return Integer.compare(bean1.getOrderNum(), bean2.getOrderNum());
}).get();
//使用基于数据流的方式，将流装载相应的 SummaryStatistics 来进行归约计算，可以实现更多的操作；
IntSummaryStatistics stats = list.stream().mapToInt(x -> x). summaryStatistics();
int max = stats.getMax()); //获取最大值
int min = stats.getMin()); //获取最小值
double sum = stats.getSum()); //获取总值
double avg = stats.getAverage()); //获取平均值
long count = stats.getCount(); //获取总数量
10） 遍历流 forEach
数据流提供了新的forEach方法遍历该流中的每个元素，方法参数为一个Lambda表达式，用于对每一个遍历的元素执行的操作；
//输出10个随机数
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);
11） 排序 sorted
sorted方法用来流排序，默认升序排布，可以使用一个 Comparator 作为参数来实现自定义排序；
//输出10个排序好的随机数
Random random = new Random();
random.ints().limit(10).sorted().forEach(System.out::println); //升序
random.ints().limit(10).sorted(x1,x2 -> Integer.compare(x2, x1)).forEach(System.out::println); //降序
12）parallelStream 并行处理
parallelStream是流 进行并行处理的替代方案，parallelStream 的底层实现为 ForkJoin 线程池，JDK8 为为 parallelStream 提供了一个通用的线程池，对于代码实际运行时的 parallelStream 线程数量是不可控的，但是可以通过设置 JVM 运行参数 -Djava.util.concurrent.ForkJoinPool.common.parallelism=N （N为线程数量）来调整 JVM ForkJoinPool 的线程数量；
List strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
//get count of empty string
int count = strings.parallelStream().filter(string -> string.isEmpty()).count();
数值流的使用
采用Stream 的 redure 方法 进行数值归约操作会涉及到基本数值类型和引用数值类型之间的装箱、拆箱操作，因此效率较低；
此时最好是将当流操作为纯数值操作时，这样使用数值流能获得较高的效率；
StreamAPI提供了三种数值流：IntStream、DoubleStream、LongStream；
1）将 Stream 转换成数值流
StreamAPI 提供了将普通流转换成数值流的三种方法：mapToInt、mapToDouble、mapToLong（参数：相应的转化Lambda表达式）；
将数值流转化为Stream 的方法：boxed；
List list = Arrays.asList(2.3,2.4,2.5,2.7,2.8);
//普通Stream转为数值Stream
DoubleStream doubles = list.stream().mapToDouble(x->x); //转化为DoubleStream
IntStream ints = list.stream().mapToInt(x->Integer.parseInt(String.format("%.0f",x))); //转化为IntStream，同时进行取舍操作
//数值Stream转为普通Stream
Stream stream = list.boxed();
2）数值流的数值计算
每种数值流都提供了数值计算函数，如max、min、sum、avg等。
List list = Arrays.asList(1,2,3,4,5,6,7);
OptionalInt max = list.stream().max();
int max_value = max.orElse(0);
OptionalInt sum = list.steam().sum();
iny sum_value = sum.orElse(0);
由于数值流可能为空，并且给空的数值流计算最大值是没有意义的，因此max函数返回OptionalInt，它是Optional的一个子类，能够判断流是否为空，并对流为空的情况作相应的处理。
此外，mapToInt、mapToDouble、mapToLong进行数值操作后的返回结果分别为：OptionalInt、OptionalDouble、OptionalLong
Stream 转换为 Collection、Array、String
Stream 可以通过 Collector 收集器，将其转化为 Array，Collection，Map，String；
① Stream -> 数组
//普通转换
Stream stream = Stream.of("are","you","ok");
String[] array = stream().toArray();
//涉及拆箱、装箱操作的转换
Stream stream = Stream.of(1,2,3,4,5,6);
int[] array = stream.mapToInt(x->x).toArray();
Integer[] array = stream.toArray(Integer[]::new);
//将 List 转化为 String[]
List list = Arrays.asList(1,2,3,4,5);
String[] array = list.stream().map(String::valueOf).toArray(String[]::new);
② Stream -> List
List list1 = stream.collect(Collectors.toList());
List list2 = stream.collect(Collectors.toCollection(ArrayList::new));
③ Stream ->Set
Set set = stream.collect(Collectors.toCollection(Set::new));
④ Stream ->Stack
Stack stack = stream.collect(Collectors.toCollection(Stack::new));
⑤ Stream ->Map
Map map = Stream.of("are","you","ok").collect(Collectors.toMap( s -> s.hashCode(), s -> s));
⑥ Stream -> String
Stream 可以很方便转化为 String，利用这一个特性，可以十分方便地将一个 Collection（List，Set等）转化为使用某个标点符号分隔的字符串；
//将 List 转化为使用 “,” 分隔的字符串
List list = Arrays.asList(1,2,3,4,5,6,7);
String str = list.stream().map(x->x.toString()).collect(Collectors.joining(","));
System.out.println(str);
//输出： 1,2,3,4,5,6,7
对 Map 使用Stream
虽然 JDK8 的 Stream API 不直接支持 Map，但是我们可以通过对 Map 的 entrySet，keySet，valueColletion 生成 Stream 来进行曲线救国，如下示例：
Map map = new HashMap(){{
put(1,"are");
put(2,"you");
put(3,"ok"); }};
map.entrySet().forEach(System.out::println); //遍历key-value
int randomKey = map.keySet().stream().findAny().orElse(-1); //随机取出一个key
String values = map.values().stream().distinct().collect(Collectors.joining(",")); //将value去重后组装成使用“，”分隔的字符串