stream中大部分方法使用了函数式编程，之前文章入门总结了函数式编程，现在总结一下stream流api

什么是流： Stream（流）是一个来自数据源的元素队列并支持聚合操作

• 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
• 数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等；
• 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。 和以前的Collection操作不同， Stream操作还有两个基础的特征；
• 内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现；

1.基本使用

1.创建流

有两种流创建 1.stream() − 为集合创建串行流。

2.parallelStream() − 为集合创建并行流。

可看出并行流输出不是按照流列表顺序输出

2.limit()

limit 方法用于获取指定数量的流。

	List<String> strings = Arrays.asList("e", "n", "d", "w", "a", "s");
	strings.parallelStream().limit(5).forEach(System.out::println);
	System.out.println("============");
	strings.stream().limit(5).forEach(System.out::println);

输出结果：并发流是最先输出的5个元素，而串行流前五个

w
a
e
d
n
============
e
n
d
w
a

3.sorted()

sorted 方法用于对流进行排序。

	strings.parallelStream().sorted().limit(5).forEach(System.out::println);
	System.out.println("============");
	strings.stream().sorted().limit(5).forEach(System.out::println);

输出结果：串行流能做到排序和并行流不可以

n
a
d
s
e
============
a
d
e
n
s

4.filter()

filter方法用于过滤流

	strings.stream().filter(i -> i.startsWith("e") || i.startsWith("n")).forEach(System.out::println);

过滤string开头不为“e”或“n”的单词，最后输出过滤剩下的；

5.collect()

collect将流中的数据收集到列表或map等集合

收集到list中：

	List<String> collect = strings.stream().filter(i -> i.startsWith("e") || i.startsWith("n"))
										   .collect(Collectors.toList());

收集到数组中：

    String[] strings1 = strings.stream().filter(i -> i.startsWith("e") || i.startsWith("n"))
                                        .toArray(String[]::new);

6.map()

对流中所有元素中映射关系，如对int流数据做计算、对string流数据做拼接

	strings.stream().map(i->i+"*").forEach(System.out::println);

最后输出的每个元素都会拼接“*”

e*
n*
d*
w*
a*
s*

7.groupingby

分组函数，根据返回值不同分组为两个list

    List<String> strings = Arrays.asList("e", "e", "d", "w", "a", "s");
	// 根据groupingby中的返回值类型，来做到分组
	Map<Boolean, List<String>> e = strings.stream().collect(Collectors.groupingBy(i -> i.startsWith("e")));
        e.forEach((k,v)->{
            System.out.println("key:" + k + "  value = " + v);
        });
    Map<String, List<String>> collect = strings.stream().collect(Collectors.groupingBy(i -> i));
        collect.forEach((k,v)->{
            System.out.println("key:" + k + "  value = " + v);
        });

根据collect函数中的Collectors.groupingby方法来选择收集的方向，如布尔值等

// 根据布尔值区分
key:false  value = [d, w, a, s]
key:true  value = [e, e]
// 根据字符串区分
key:a  value = [a]
key:s  value = [s]
key:d  value = [d]
key:e  value = [e, e]
key:w  value = [w]

8.partioningBy

和groupingby很相似这个名叫分区，只能按照符合的布尔条件，分为true、false两组条件，groupingby相当partioningby的更广泛方法，可以依据任何泛型分类。

 	Map<Boolean, List<String>> e = strings.stream().collect(Collectors.groupingBy(i -> i.startsWith("e")));
        e.forEach((k, v) -> {
            System.out.println("key:" + k + "  value = " + v);
        });

    Map<Boolean, List<String>> e1 = strings.stream().collect(Collectors.partitioningBy(i -> i.startsWith("e")));
        e1.forEach((k, v) -> {
            System.out.println("key:" + k + "  value = " + v);
        });

返回结果是一样的

key:false  value = [d, w, a, s]
key:true  value = [e, e]
key:false  value = [d, w, a, s]
key:true  value = [e, e]

附录：Collectors详细静态工厂方法

结论：

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种函数式方式处理数据。 同时里面提供了一系列便捷的流处理方法，可以帮助我们对元素分类、筛选、收集、组合、排序等； 里面大量方法参数使用了Functional Interface，我们可以通过函数式编程快速实现想要操作的步骤✿ Random里面可以ints()|doubles()可以产生随机流，供我们对产生随机数排序、输出等

参考： https://blog.csdn.net/weixin_43318134/article/details/104442023

https://blog.csdn.net/love_moon821/article/details/90443778