stream归约与收集(终止操作)——Java8新特性

package com.example.demo.lambdaStreamAPI;

import com.example.demo.lambda.Employee;
import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @Description stream api
 * stream api 的操作步骤：
 *      1. 创建stream
 *      2. 中间操作
 *      3. 终止操作（终端操作）
 *
 * @Auther gf.x
 * @Date 2020/3/29 21:28
 */
public class StreamAPITest3 {

    //三. 终止操作
    /**
     * 归约与收集：
     * reduce(T identity, BinaryOperator)/reduce(BinaryOperator)：可以将流中元素反复结合起来，得到一个值。
     * collect：将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法。
     *
     * 备注：map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它来进行网络搜索而出名。
     */

    List<Employee> emps = Arrays.asList(
            new Employee("李四", 59, 6666.66, Employee.Status.BUSY),
            new Employee("张三", 18, 9999.99, Employee.Status.FREE),
            new Employee("王五", 28, 3333.33, Employee.Status.VOCATION),
            new Employee("赵六", 8, 7777.77, Employee.Status.BUSY),
            new Employee("赵六", 8, 7777.77, Employee.Status.FREE),
            new Employee("赵六", 8, 7777.77, Employee.Status.FREE),
            new Employee("田七", 38, 5555.55, Employee.Status.BUSY)
    );

    //1. reduce归约
    @Test
    public void test() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        Integer sum = list.stream()
                //.reduce(0, Integer::sum)
                .reduce(0, (x, y) -> x + y);
        System.out.println(sum);

        System.out.println("---------------------");

        Optional<Double> reduceSum = emps.stream()
                                         .map(Employee::getSalary)
                                         .reduce(Double::sum);
        System.out.println(reduceSum.get());
    }

    //2. collect收集
    @Test
    public void test1() {
        List<String> collectList = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toList());
        System.out.println(collectList);

        System.out.println("--------------------");

        Set<String> collectSet = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toSet());
        System.out.println(collectSet);

        System.out.println("--------------------");

        HashSet<String> collectHashSet = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toCollection(HashSet::new));
        System.out.println(collectHashSet);
    }

    @Test
    public void test2() {
        //总数
        Long count = emps.stream()
                .collect(Collectors.counting());
        System.out.println(count);

        //平均值
        Double avg = emps.stream()
                //.map(Employee::getSalary)
                .collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(avg);

        //总和
        Double sum = emps.stream()
                .collect(Collectors.summingDouble(Employee::getSalary));
        System.out.println(sum);

        //最大值
        Optional<Employee> op = emps.stream()
                //.max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
                .collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
        System.out.println(op.get());

        //最小值
        Optional<Double> min = emps.stream()
                //.map(Employee::getSalary).min(Double::compare);
                .map(Employee::getSalary)
                .collect(Collectors.minBy(Double::compare));
        System.out.println(min.get());
    }

    //分组
    //Map<Employee.Status, List<Employee>> : 按员工的状态对员工进行分组 ☆☆☆☆☆
    @Test
    public void test3() {
        Map<Employee.Status, List<Employee>> collectMap = emps.stream()
                .collect(Collectors.groupingBy(Employee::getStatus));
        System.out.println(collectMap);
    }

    //多级分组
    //Map<Employee.Status, Map<String, List<Employee>>> : 先按员工状态对员工进行分组 然后再按年龄进行分组 ☆☆☆☆☆
    @Test
    public void test4() {
        Map<Employee.Status, Map<String, List<Employee>>> collect = emps.stream()
                .collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
                    if (e.getAge() <= 35) {
                        return "青年";
                    } else if (e.getAge() <= 50) {
                        return "中年";
                    } else {
                        return "老年";
                    }
                })));

        System.out.println(collect);
    }

    //分区
    @Test
    public void test5() {
        Map<Boolean, List<Employee>> partCollect = emps.stream()
                .collect(Collectors.partitioningBy((e) -> e.getSalary() >= 5000));

        System.out.println(partCollect);
    }

    //Double汇总统计
    @Test
    public void test6() {
        DoubleSummaryStatistics doubleSummary = emps.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));

        System.out.println(doubleSummary.getMax());
        System.out.println(doubleSummary.getAverage());
        System.out.println(doubleSummary.getCount());
        System.out.println(doubleSummary.getSum());
    }

    //连接/拼接
    //joining() 直接拼接
    //joining(CharSequence delimiter) 添加分隔符
    //joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix) 添加分隔符 前缀 后缀
    @Test
    public void test7() {
        String collectJoining = emps.stream()
                .map(Employee::getName)
                //.collect(Collectors.joining())
                //.collect(Collectors.joining(","))
                .collect(Collectors.joining(",", "“", "”"))
                ;

        System.out.println(collectJoining);
    }
}