08. Java8-流式API-终端操作collect

朱雀 2022-02-02 01:36 233阅读 0赞

集合的stream()方法是将集合转换为流形式以处理数据, Stream的collect 是将流转换为集合或其它形式存储流运算结果. Collector 接口中方法的实现决定了如何对流执行收集操作,但并非一定要自己去实现此接口, Collectors 实现类提供了很多静态方法, 可以便捷地创建收集器实例.

## 1. 常用收集器 ##

> 测试数据如下:

static List<Employee> emps = new ArrayList<>();
    
    static { 
    
        emps.add(new Employee(1001, "张三", "Man", 50));
        emps.add(new Employee(1002, "李四", "Man", 30));
        emps.add(new Employee(1003, "王五", "Woman", 25));
        emps.add(new Employee(1004, "赵六", "Man", 35));
        emps.add(new Employee(1005, "小七", "Woman", 30));
        emps.add(new Employee(1006, "周八", "Man", 42));
    }

### 1.1 toList ###

> 将流元素收集到ArrayList 中.

// 将处理后的流中所有元素收集到list中,list 为 java.util.ArrayList
    @Test
    public void test_toList(){ 
    
        List<String> list = emps.stream()
                .filter((employee -> "Woman".equals(employee.getSex())))
                .map((employee -> employee.getName()))
                .collect(Collectors.toList());
    
        list.forEach(System.out::println);
        System.out.println(list.getClass());
    }

### 1.2 toSet ###

> 将流元素收集到HashSet 中

// 将处理后的流中所有元素收集到Set 中, Set为 java.util.HashSet
    @Test
    public void test_toSet(){ 
        Set<String> set = emps.stream()
                .filter((employee -> "Man".equals(employee.getSex())))
                .map((employee -> employee.getName()))
                .collect(Collectors.toSet());
    
        set.forEach(System.out::println);
        System.out.println(set.getClass());
    }

### 1.3 toCollection ###

> 将流元素收集到自定义容器中

// 自定义集合数据结构
    @Test
    public void test_toCollection(){ 
        Set<String> set = emps.stream()
                .filter((employee -> "Man".equals(employee.getSex())))
                .map((employee -> employee.getName()))
                .collect(Collectors.toCollection(LinkedHashSet::new));
    
        System.out.println(set.getClass());
    
    }

### 1.4 counting ###

> 计算流中元素个数

//获取流中元素总数量
    @Test
    public void test_counting(){ 
        Long total = emps.stream().collect(Collectors.counting());
        System.out.println("流中元素总数量: " + total);
    }

### 1.5 aggregation ###

> 聚合操作, 包含: counting(), maxBy(), minBy(), summingInt(), averagingInt(), summingLong(), averagingLong(), summingDouble(), averagingDouble() 等API

// 测试聚合函数
    @Test
    public void test_aggregation(){ 
        Long count = emps.stream().collect(Collectors.counting());
        Integer sum = emps.stream().collect(Collectors.summingInt(Employee::getAge));
        Double average = emps.stream().collect(Collectors.averagingInt(Employee::getAge));
        Optional<Employee> maxOp = emps.stream().collect(Collectors.maxBy((e1, e2) -> e1.getAge().compareTo(e2.getAge())));
        Optional<Employee> minOp = emps.stream().collect(Collectors.minBy((e1, e2) -> e1.getAge().compareTo(e2.getAge())));
    
        System.out.println("员工列表中男性总数量: " + count);
        System.out.println("员工列表中男性总年龄: " + sum);
        System.out.println("员工列表中男性平均年龄: " + average);
        System.out.println("员工列表中男性最大年龄: " + maxOp.get());
        System.out.println("员工列表中平均年龄: " + minOp.get());
    }

// 对Int类型做聚合运算,形似API 还有summarizingDouble, summarizingLong
    @Test
    public void test_summarizingInt(){ 
        // 对于自定义对象流,可使用collect 获取*statistics 聚合函数信息, 对于特定流 Int/Double/LongStream, 提供了对应的方法
        IntSummaryStatistics statistics = emps.stream()
                .filter((employee -> "Man".equals(employee.getSex())))
                .collect(Collectors.summarizingInt(Employee::getAge));
    
        System.out.println("员工列表中男性总数量: " + statistics.getCount());
        System.out.println("员工列表中男性总年龄: " + statistics.getSum());
        System.out.println("员工列表中男性平均年龄: " + statistics.getAverage());
        System.out.println("员工列表中男性最大年龄: " + statistics.getMax());
        System.out.println("员工列表中平均年龄: " + statistics.getMin());
    
        DoubleSummaryStatistics dbStatistics = DoubleStream.of(10.0, 15.5, 20.5, 31.5, 40.0).summaryStatistics();
        System.out.println("流中元素总数量:" + dbStatistics.getCount());
        System.out.println("流中元素总和:" + dbStatistics.getSum());
        System.out.println("流中元素平均值:" + dbStatistics.getAverage());
        System.out.println("流中元素最大值:" + dbStatistics.getMax());
        System.out.println("流中元素最小值:" + dbStatistics.getMin());
    
    }

### 1.6 groupingBy ###

> 将流中元素进行分组

// 分组函数: 可进行一级或多级分组, 返回为map 结构
    @Test
    public void test_groupingBy(){ 
    
        // 一级分组: 按性别分组
        Map<String, List<Employee>> sexMap = emps.stream().collect(Collectors.groupingBy(Employee::getSex));
    
        // 而二级分组: 先按性别分组, 再按年龄分组
        Map<String, Map<String, List<Employee>>> map = emps.stream()
                .collect(Collectors.groupingBy(Employee::getSex,
                        Collectors.groupingBy((employee) -> { 
                            if (employee.getAge() < 20) { 
                                return "青年";
                            } else if (employee.getAge() < 40) { 
                                return "中年";
                            } else { 
                                return "老年";
                            }
                        })));
    
        System.out.println(sexMap);
        System.out.println(map);
    }

### 1.7 partitional ###

> 将流中元素进行分区.

// 分区,按照是否满足条件分为两组, 可嵌套分组
    @Test
    public void test_partitional(){ 
        // 一级分组
        Map<Boolean, List<Employee>> map1 = emps.stream()
                .collect(Collectors.partitioningBy((employee) -> employee.getAge() > 30));
        System.out.println("年龄大于30岁的: " + map1.get(true));
        System.out.println("年龄小于30岁的: " + map1.get(false));
    
        System.out.println("----------------------------------------------------------------------------------");
    
        // 多机分组
        Map<Boolean, Map<Boolean, List<Employee>>> map2 = emps.stream()
                .collect(Collectors.partitioningBy((employee) -> employee.getAge() > 30,
                        Collectors.partitioningBy((employee) -> "Man".equals(employee.getSex()))));
    
        System.out.println("年龄大于30岁的男性: " + map2.get(true).get(true));
        System.out.println("年龄大于30岁的女性: " + map2.get(true).get(false));
        System.out.println("年龄小于30岁的男性: " + map2.get(false).get(true));
        System.out.println("年龄小于30岁的女性: " + map2.get(false).get(false));
    
    }

### 1.8 join ###

> 对流中元素进行字符串拼接.

// 拼接字符串
    @Test
    public void test_join(){ 
    
        String names = emps.stream()
                .map((employee -> employee.getName()))
                .collect(Collectors.joining(",", "(", ")"));
    
        System.out.println(names);
    
    }

### 1.9 reducing ###

> 对流中元素做迭代式运算.

// reducing 对流中元素做聚合运算, 类似于stream.reduce()
    @Test
    public void test_reducing(){ 
    
        Integer sum = emps.stream().collect(Collectors.reducing(0, Employee::getAge, Integer::sum));
        System.out.println(sum);
    }

### 1.10 collectingAndThen ###

> 包裹另外一个收集器, 对其结果做转换函数.

// 包含另外一个收集器
    @Test
    public void test_collectingAndThen(){ 
        Integer size = emps.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));
        System.out.println(size);
    }