Java8 Stream的各种使用姿势

太过爱你忘了你带给我的痛 2023-07-17 02:49 24阅读 0赞

## `Stream`简介 ##

`Java` 8 `API`添加了一个新的抽象称为流(`Stream`)，它可以让你以一种声明的方式处理数据。这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。

> 概括来说：`Stream`的出生就是为了代码好看、为了性能高

### 如何Debug ###

在`IDEA`的`Debug`窗口找到`Trace Current Stream Chain`按钮，点击打开就行啦。

## `Stream`常用到的方法 ##

List<TestRes> list = Arrays.asList(
    	new TestRes().setId(1L).setSiteId(1L),
    	new TestRes().setId(2L).setSiteId(1L),
    	new TestRes().setId(3L).setSiteId(2L),
    	new TestRes().setId(4L).setSiteId(2L),
    	new TestRes().setId(5L).setSiteId(2L),
    	new TestRes().setId(6L).setSiteId(2L)
    );
    
    // 1. map(), 维度不变, 一一映射
    // List<Long> idList = list.stream().map(e -> { 
    // return e.getId();
    // }).collect(Collectors.toList());
    List<Long> idList = list.stream().map(TestRes::getId).collect(Collectors.toList());
    
    // 2. reduce(), 降维处理, 允许默认值
    Integer result = Arrays.stream(
        new Integer[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9}
    ).reduce(0, Integer::sum);
    
    // 3. filter(), 过滤器
    // List<TestRes> resList = list.stream().filter(e -> { 
    // return e.getId() >= 3L;
    // }).collect(Collectors.toList());
    List<TestRes> resList = list.stream().filter(
        e -> e.getId() >= 3L
    ).collect(Collectors.toList());
    
    // 4. limit(), 限制流数量
    List<TestRes> limitResList = list.stream().limit(3).collect(Collectors.toList());
    
    // 5. count(), 计数
    long count = list.stream().filter(Objects::nonNull).count();
    
    // 6. sort(), 排序, 可自定义比较器
    List<Integer> sortList = Arrays.stream(
        new Integer[]{ 9, 8, 7, 6, 5, 4, 3, 2, 1}
    ).sorted().collect(Collectors.toList());

### 根据Map的Value排序 ###

Map<Long, TestRes> map = new HashMap<>();
    map.put(1L, new TestRes().setId(1L).setHits(3));
    map.put(2L, new TestRes().setId(2L).setHits(5));
    map.put(3L, new TestRes().setId(3L).setHits(2));
    map.put(4L, new TestRes().setId(4L).setHits(4));
    map.put(5L, new TestRes().setId(5L).setHits(1));
    
    List<TestRes> sortResult = new ArrayList<>();
    map.entrySet().stream().sorted(
        Comparator.comparingInt(o -> o.getValue().getHits())
    ).forEachOrdered(entry -> { 
        sortResult.add(entry.getValue());
    });

> 其他操作：  
> `.distinct()` 去重;  
> `.flatMap()` 流的扁平化操作;  
> `.forEach()` 遍历, void式操作; `.peek()` 遍历, 返回新的流;  
> `.findFirst()` 查找第一个满足条件的元素; `.findAny()` 查找任一满足条件的元素  
> `.anyMatch()` 有无匹配元素; `.allMatch()` 是否全部匹配; `.noneMatch()` 是否无一匹配;  
> `.max()` 找最大值, 可自定义比较器; `.min()` 找最小值, 可自定义比较器;

## `Stream`常用到的收集器 ##

// 1. toList()
    // 2. groupingBy()
    Map<Long, List<TestRes>> listMap = list.stream().collect(
        Collectors.groupingBy(TestRes::getSiteId, Collectors.toList())
    );
    
    // 3. toMap()
    Map<Long, TestRes> resMap = list.stream().collect(
        Collectors.toMap(TestRes::getId, Function.identity())
    );
    
    // 4. toSet()
    Set<String> set = Arrays.stream(
        new String[]{ "Java", "Python", "C", "Java"}
    ).collect(Collectors.toSet());
    
    // 5. joining()
    String join = list.stream().map(
        e -> e.getId().toString()
    ).collect(Collectors.joining(","));

## `Stream`使用时性能隐患注意点 ##

### 处理N+1查询 ###

/************************************************************************* * 【需求：查询所有站点下的全部资源，并打印所有资源及其所属站点】 *************************************************************************/
    List<Site> sites = siteService.selectByExample(
        Example.builder(Site.class).andWhere(
            Sqls.custom().andIn("id", Arrays.asList(58L, 49L, 76L, 91L, 81L))
        ).build()
    );
    
    /******************************** old ********************************/
    long to1 = Instant.now().toEpochMilli();
    sites.forEach(site -> { 
        List<TestRes> resList = resService.select(
            new TestRes().setSiteId(site.getId())
        );
        resList.forEach(res -> { 
            // System.out.println(
            // String.format("%s, res from ==> %s", res.getName(), site.getName())
            // );
        });
    });
    log.info("old method complete in ==> {}", Instant.now().toEpochMilli() - to1);
    // old method complete in ==> 627
    
    /******************************** new ********************************/
    long tn1 = Instant.now().toEpochMilli();
    // 批量查询所有资源
    List<Long> siteIds = fors.stream().map(Site::getId).collect(Collectors.toList());
    List<TestRes> resList = resService.selectByExample(
        Example.builder(TestRes.class).andWhere(Sqls.custom().andIn("siteId", siteIds)).build()
    );
    
    // 构造站点映射集
    Map<Long, Site> siteMap = sites.stream().collect(
        Collectors.toMap(Site::getId, Function.identity())
    );
    
    // 根据站点映射集查找词条所属站点
    resList.forEach(res -> { 
        Site site = siteMap.getOrDefault(res.getSiteId(), new Site().setName("-"));
        // System.out.println(
        // String.format("%s, page from ==> %s", res.getName(), site.getName())
        // );
    });
    log.info("new method complete in ==> {}", Instant.now().toEpochMilli() - tn1);
    // new method complete in ==> 86

> 结果显示，老方法耗时627ms, 使用IN查询+映射集只需要86ms

### 树形结构建立 ###

/************************************************************************* * 【需求：将某篇资源的所有评论整理成树形结构（root 10个元素，2层树形）】 *************************************************************************/
    /******************************** old ********************************/
    long to2 = Instant.now().toEpochMilli();
    // 查询一级评论
    List<Comment> parentComments = commentService.selectByExample(
        Example.builder(Comment.class).andWhere(
            Sqls.custom().andEqualTo("sourceId", 1L).andIsNull("childOfId")
        ).orderByDesc("createdAt").build()
    );
    
    // 遍历一级评论构造子评论列表
    List<List<Comment>> resultOld = parentComments.stream().map(parentComment -> { 
        List<Comment> childs = commentService.select(
            new Comment().setSourceId(parentComment.getSourceId()).setChildOfId(parentComment.getId())
        );
        // do something
        return childs;
    }).collect(Collectors.toList());
    log.info("old tree build in ==> {}", Instant.now().toEpochMilli() - to2);
    // old tree build in ==> 1219
    
    /******************************** new ********************************/
    long tn2 = Instant.now().toEpochMilli();
    // 查询所有评论
    List<Comment> comments = commentService.selectByExample(
        Example.builder(Comment.class).andWhere(
            Sqls.custom().andEqualTo("sourceId", 1L)
        ).orderByDesc("createdAt").build()
    );
    
    // 根据评论父ID分组
    Map<Long, List<Comment>> commentsMap = comments.stream().filter(
        e -> null != e.getChildOfId()
    ).collect(
        Collectors.groupingBy(Comment::getChildOfId, Collectors.toList())
    );
    
    // 筛选一级评论
    List<Comment> rootComments = comments.stream().filter(
        e -> null == e.getChildOfId()
    ).collect(Collectors.toList());
    
    // 遍历一级评论，查找映射集中的子评论列表
    List<List<Comment>> resultNew = rootComments.stream().map(e -> { 
        List<Comment> childs = commentsMap.getOrDefault(e.getId(), Collections.emptyList());
        // do something
        return childs;
    }).collect(Collectors.toList());
    log.info("new tree build in ==> {}", Instant.now().toEpochMilli() - tn2);
    // new tree build in ==> 98

> 结果显示，老方法耗时1219ms, 使用新方法构造树只需要98ms

### 结论 ###

尽量避免在`stream`中间函数做数据库查询，若情况合适，利用流式特性直接在内存进行筛选分组等操作，以此优化性能。