一文了解Stream流(超详细+干货满满)

Stream流是对集合对象功能的增强，专注于对集合对象进行各种便利、高效的聚合操作或者大批量数据操作

//java.util.Collection.stream()方法用集合创建流
//Arrays.asList是将数组转化成List集合的方法
List list = Arrays.asList("hello","world","stream");
//创建顺序流
Stream stream = list.stream();
//创建并行流
Stream parallelStream = list.parallelStream();

//java.util.Arrays.stream(T[] array)方法用数组创建流
String[] array = {"h", "e", "l", "l", "o"};
Stream arrayStream = Arrays.stream(array);

filter：筛选，是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作

public static void main(String[] args) {
    List list = Arrays.asList(6, 7, 3, 8, 1, 2);
    Stream stream = list.stream();
    stream.filter(x -> x > 5).forEach(System.out::println);
}
//结果如下：
6
7
8

 映射（map、flatMap、peek）

map：一个元素类型为T的流转换成元素类型为R的流，这个方法传入一个Function的函数式接口，接收一个泛型T，返回泛型R，map函数的定义，返回的流，表示的泛型是R对象，简言之将集合中的元素A转换成想要得到的B

flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

简言之：与Map功能类似，区别在于将结合A的流转换成B流

 distinct：简而言之就是去重

Stream stream = Stream.of("1", "3","4","10","4","6","23","3");
stream.distinct().forEach(System.out::println);
 
//输出
1
3
4
10
6
23

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

List strAry = Arrays.asList( "Jhonny", "David", "Jack", "Duke", "Jill","Dany","Julia","Jenish","Divya");
 
strAry.stream().forEach(s-> {
			if("Jack".equalsIgnoreCase(s)) System.out.println(s);
		});
 
//输出
Jack

 collect：称为收集器，是一个终端操作,它接收的参数是将流中的元素累积到汇总结果的各种方式

//把流中所有元素收集到List中
List menus=Menu.getMenus.stream().collect(Collectors.toList());
//把流中所有元素收集到Set中,删除重复项
Set menus=Menu.getMenus.stream().collect(Collectors.toSet());
//把流中所有元素收集到给定的供应源创建的集合中
ArrayList menus=Menu.getMenus.stream().collect(Collectors.toCollection(ArrayList::new));
//对流中元素的一个整数属性求和
Long count=Menu.getMenus.stream().collect(counting);
//计算流中元素integer属性的平均值
Integer count=Menu.getMenus.stream().collect(summingInt(Menu::getCalories));
//连接流中每个元素的toString方法生成的字符串
Double averaging=Menu.getMenus.stream().collect(averagingInt(Menu::getCalories));
//一个包裹了流中按照给定比较器选出的最大元素的optional，如果为空返回的是Optional.empty()
Optional fattest=Menu.getMenus.stream().collect(maxBy(Menu::getCalories));
//一个包裹了流中按照给定比较器选出的最小元素的optional，如果为空返回的是Optional.empty()
 Optional lessest=Menu.getMenus.stream().collect(minBy(Menu::getCalories));

//max：根据提供的Comparator返回此流的最大元素
List num = Arrays.asList( 4, 5, 6);
num.stream().max(Integer::compareTo).ifPresent(System.out::println);
 
//输出
6

//min：根据提供的Comparator返回此流的最小元素
List num = Arrays.asList( 4, 5, 6);
num.stream().min(Integer::compareTo).ifPresent(System.out::println);
 
//输出
4

//count：返回此流中的元素计数
List num = Arrays.asList( 4, 5, 6);
System.out.println(num.stream().count());
 
//输出
3

 整体举例

return userList.stream().filter(user -> {
            String userTags = user.getTags();
            if (StringUtils.isBlank(userTags)){
                return false;
            }
            Set tagNameSet = gson.fromJson(userTags, new TypeToken>() {}.getType());
            for (String tagName : tagNameSet) {
                //若有标签不存在
                if (!tagNameSet.contains(tagName)) {
                    return false;
                }
            }
            //所有标签都存在
            return true;
        }).map(this::getSafetyUser).collect(Collectors.toList());