使用场景 复杂数据的处理 stream流天下无敌

Stream流可以让数据处理更加简单
写起来更加方便 阅读性也更强
ps：并行流在处理超大的数据量是速度快很多

1.1流的获取

常用开流

ArrayList<Object> list = CollUtil.newArrayList(1,2,3);//hutool
//最常用开流
list.stream();
//100w+的复杂数据操作 并行流可以调用全部cpu 但是数据量少非常不适合
list.parallelStream()
//不常用开流
Stream.of(list).forEach();

Map开流有一点不一样

//双列：Map不能直接获取流对象
keySet().stream();    所有键的流
values().stream();    所有值的流
entrySet().stream();  所有键值对的流

1.2Stream类静态方法

迭代流iterate

//从0开始 逐个+2 的十个数字
Stream.iterate(0,x->x+2).limit(10).forEach(System.out::print);

无序流generate

//5个随机数 
Stream.generate(Math::random).limit(5).forEach(System.out::print);

2.1截取和切片

filter（常用）

过滤得到符合条件的数据

//过滤掉为空的数据
sortBuilders.stream().filter(Objects::nonNull).forEach(requestBuilder::addSort);

limit&skip

//截取只要前五个数据
sortBuilders.stream().limit(5).forEach(requestBuilder::addSort);
//不要前十个数据
sortBuilders.stream().skip(10).forEach(requestBuilder::addSort);

distinct去重（常用）

sortBuilders.stream().distinct().forEach(requestBuilder::addSort);

3.1遍历数据

map遍历每一个数据(常用)

ps:遍历之后返回执行结果

nodeInfos.stream().map(NodeInfo::getId).forEach(System.out::print);

peek遍历每一个数据(常用)

ps:遍历之后不执行结果
注意坑！ 如果这个方法结尾不是count/collect会不生效
JDK10之后 peek+count也会失效
peek原本设计之初就是用来debug数据的 虽然也挺好用
某些情况可以用foreach代替

ArrayList<Object> list = CollUtil.newArrayList();
nodeInfos.stream().peek(list::add).forEach(System.out::print);

flatMap 把集合打散 遍历每一个数据(常用)

List<List<Bean>>怎么办 flatMap可以把集合直接打散成 Bean，Bean，Bean，Bean...

relationConfigEntities.stream()
                .map(GraphRelationConfigEntity::getRelations)
                //解析成JSONArray
                .map(JSON::parseArray)
                //将解析的多个数组 全部打散成一个个的数据
                .flatMap(Collection::stream)
                .map(Object::toString)
                //set去重
                .collect(Collectors.toSet());

foreach 遍历

比较特殊 后面说

4.1流的结束

流都是要结束的

foreach 遍历

可以看到前面的例子都是有结尾的

搜索方法（不常用）

#里面是不是全叫pdd
 boolean isPdd = nodeInfos.stream().map(NodeInfo::getLabel).allMatch("pdd"::equals);

同理还有

anyMatch#有任何一个
noneMatch#没用一个匹配
findFirst/findAny#返回第一个元素/返回任意/
count#数量
max/min//最大最小

nodeInfos.stream().peek(list::add).forEach(System.out::print);

X.x特殊

去重

针对list中map的某个属性去重（针对bean来去重更简单）

  //map自定义去重方法
   List<Map<String,String>> distinctResp = resp.stream()
                .filter(distinctByKey(temMap -> {
                    //如果是key1 = value 则根据type进行去重
                    if ("value1".equals(temMap.get("key1"))) {
                        return temMap.get("type");
                    }
                    //否则对整个对象去重
                    return temMap;
                }))
                .collect(Collectors.toList());

   /**
     * 自定义去重方法
     *
     * @param keyExtractor
     * @param <T>
     * @return
     */
    public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

数据解析 打撒去重

 Set<String> relations = relationConfigEntities.stream()
                .map(GraphRelationConfigEntity::getRelations)
                //解析成JSONArray
                .map(JSON::parseArray)
                //将解析的多个数组 全部打散成一个个的数据
                .flatMap(Collection::stream)
                .map(Object::toString)
                //set去重
                .collect(Collectors.toSet());