lambda的peek，filter，map，collect函数使用

@RequestMapping(value = "/list.json", method = GET)
public void list(ModelMap modelMap, String taskId, Integer currentPage, Integer pageSize) {
    Pagination pagination = Pagination.builder().current(currentPage).pageSize(pageSize).build();
    if (StringUtils.isNotBlank(taskId)) {
        return;
    }
    Map<Long, TaskBO> taskMap = Maps.newHashMap();
    Pager<RecordBO> boPager = recordManager.findRecordList(taskId, pagination);
    modelMap.addAttribute(KEY_DATA, new Pager<>(pagination,
            boPager.getList()
                    .stream()
                    .peek(recordBO -> {
                        if (!taskMap.containsKey(recordBO.getTaskId())) {
                            Optional<TaskBO> optionalTaskBO = taskManager.get(recordBO.getTaskId());
                            optionalTaskBO.ifPresent(taskBO -> taskMap.put(recordBO.getTaskId(), taskBO));
                        }

                    })
                    .filter(recordBO -> taskMap.containsKey(recordBO.getTaskId()))
                    .map(recordBO -> {
                        TaskBO taskBO = taskMap.get(recordBO.getTaskId());
                        return RecordVO.read4BO(recordBO, taskBO.getId() + ": " + taskBO.getName());
                    })
                    .collect(Collectors.toList())));

}

1. distinct: 对于Stream中包含的元素进行去重操作（去重逻辑依赖元素的equals方法），新生成的Stream中没有重复的元素；

distinct方法示意图(**以下所有的示意图都要感谢[RxJava](https://github.com/Netflix/RxJava)项目的doc中的图片给予的灵感, 如果示意图表达的有错误和不准确的地方，请直接联系我。**)：

2. filter: 对于Stream中包含的元素使用给定的过滤函数进行过滤操作，新生成的Stream只包含符合条件的元素；

filter方法示意图：

3. map: 对于Stream中包含的元素使用给定的转换函数进行转换操作，新生成的Stream只包含转换生成的元素。这个方法有三个对于原始类型的变种方法，分别是：mapToInt，mapToLong和mapToDouble。这三个方法也比较好理解，比如mapToInt就是把原始Stream转换成一个新的Stream，这个新生成的Stream中的元素都是int类型。之所以会有这样三个变种方法，可以免除自动装箱/拆箱的额外消耗；

map方法示意图：

4. flatMap：和map类似，不同的是其每个元素转换得到的是Stream对象，会把子Stream中的元素压缩到父集合中；

flatMap方法示意图：

5. peek: 生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数（Consumer实例），新Stream每个元素被消费的时候都会执行给定的消费函数；

peek方法示意图：

6. limit: 对一个Stream进行截断操作，获取其前N个元素，如果原Stream中包含的元素个数小于N，那就获取其所有的元素；

limit方法示意图：

7. skip: 返回一个丢弃原Stream的前N个元素后剩下元素组成的新Stream，如果原Stream中包含的元素个数小于N，那么返回空Stream；

skip方法示意图：

8. 在一起,在一起！

 
       1 
       List<Integer> nums = Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10); 
      
       2 
       System.out.println(“sum is:”+nums.stream().filter(num -> num != null). 
      
       3 
                   distinct().mapToInt(num -> num * 2). 
      
       4 
                   peek(System.out::println).skip(2).limit(4).sum());

这段代码演示了上面介绍的所有转换方法（除了flatMap），简单解释一下这段代码的含义：给定一个Integer类型的List，获取其对应的Stream对象，然后进行过滤掉null，再去重，再每个元素乘以2，再每个元素被消费的时候打印自身，在跳过前两个元素，最后去前四个元素进行加和运算(解释一大堆，很像废话，因为基本看了方法名就知道要做什么了。这个就是声明式编程的一大好处！)。大家可以参考上面对于每个方法的解释，看看最终的输出是什么。
9. 性能问题
有些细心的同学可能会有这样的疑问：在对于一个Stream进行多次转换操作，每次都对Stream的每个元素进行转换，而且是执行多次，这样时间复杂度就是一个for循环里把所有操作都做掉的N（转换的次数）倍啊。其实不是这样的，转换操作都是lazy的，多个转换操作只会在汇聚操作（见下节）的时候融合起来，一次循环完成。我们可以这样简单的理解，Stream里有个操作函数的集合，每次转换操作就是把转换函数放入这个集合中，在汇聚操作的时候循环Stream对应的集合，然后对每个元素执行所有的函数。

lambda的peek，filter，map，collect函数使用

猜你喜欢