Java8——Stream流的使用(收集操作)(四)

Java8——Stream流的使用(收集操作)
4.3 使用案例
/**
 * @author lx
 */
public class CollectGrouping {

    /**
     * groupingBy 一个参数
     */
    @Test
    public void groupingByOne() {

        //对不同等级的学生进行收集分组
        Map<Integer, List<Student>> gradeMap = students.stream().collect(groupingBy(Student::getGrade));
        System.out.println(gradeMap);


        //对不同分数的学生进行收集分组,自定义分组规则
        Map<Integer, List<Student>> collect = students.stream().collect(groupingBy(
                //通过函数自定义分组规则
                student -> {
                    int score = student.getScore();
                    if (score >= 90) {
                        return 1;
                    } else if (score >= 70) {
                        return 2;
                    } else {
                        return 3;
                    }
                }));
        System.out.println(collect);
    }

    /**
     * groupingBy 两个参数
     * 第二个Collector参数可以实现各种收集逻辑
     */
    @Test
    public void groupingByTwo() {
        //对不同等级的学生进行收集分组,使用List收集value元素,实际上就是上面单参数groupingBy内部调用的方法
        Map<Integer, List<Student>> collectList = students.stream().collect(groupingBy(Student::getGrade,
                toList()));
        System.out.println(collectList);
        System.out.println("=============");

        //对不同等级的学生进行收集分组,使用ArrayList收集元素
        Map<Integer, ArrayList<Student>> collectArrayList = students.stream().collect(groupingBy(Student::getGrade,
                toCollection(ArrayList::new)));
        System.out.println(collectArrayList);
        System.out.println("=============");

        //对不同等级的学生进行收集分组,使用HashSet收集元素
        Map<Integer, HashSet<Student>> collectSet = students.stream().collect(groupingBy(Student::getGrade,
                toCollection(HashSet::new)));
        System.out.println(collectSet);

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

        //对不同等级的学生进行收集分组,使用Map收集同组学生的id-name
        Map<Integer, Map<Integer, String>> collect = students.stream().collect(groupingBy(Student::getGrade,
                toMap(Student::getId, Student::getName)));
        System.out.println(collect);
        System.out.println("=============");


        //对不同等级的学生进行收集分组,使用Integer收集同组学生的人数
        Map<Integer, Long> collectCounting = students.stream().collect(groupingBy(Student::getGrade,
                counting()));
        System.out.println(collectCounting);
        System.out.println("=============");
        //对不同等级的学生进行收集分组,使用TreeMap收集同组学生的id-name并根据id大小倒序排序
        Map<Integer, TreeMap<Integer, String>> collect1 = students.stream().collect(groupingBy(Student::getGrade,
                toMap(Student::getId, Student::getName, (x, y) -> x,
                        () -> new TreeMap<>(Comparator.comparingInt(o -> (int) o).reversed()))));
        System.out.println(collect1);
    }

    /**
     * groupingBy 三个参数
     * 多了一个可以指定外层Map类型的参数
     */
    @Test
    public void groupingByThr() {
        //对不同等级的学生进行收集分组,外层使用TreeMap排序
        TreeMap<Integer, List<Student>> collectTreeMap = students.stream().collect(groupingBy(Student::getGrade,
                TreeMap::new,
                toList()));
        System.out.println(collectTreeMap);

    }

    /**
     * groupingByConcurrent 一个参数,和groupingBy差不多,区别就是外层Map是安全的
     */
    @Test
    public void groupingByConcurrentByOne() {
        //对不同等级的学生进行收集分组
        ConcurrentMap<Integer, List<Student>> gradeMap = students.stream().collect(groupingByConcurrent(Student::getGrade));
        System.out.println(gradeMap);


        //对不同分数的学生进行收集分组,自定义分组规则
        ConcurrentMap<Integer, List<Student>> collect = students.stream().collect(groupingByConcurrent(
                //通过函数自定义分组规则
                student -> {
                    int score = student.getScore();
                    if (score >= 90) {
                        return 1;
                    } else if (score >= 70) {
                        return 2;
                    } else {
                        return 3;
                    }
                }));
        System.out.println(collect);
    }


    /**
     * groupingByConcurrent 两个参数,和groupingBy差不多,区别就是外层Map是安全的
     */
    @Test
    public void groupingByConcurrentByTwo() {
        //对不同等级的学生进行收集分组
        ConcurrentMap<Integer, List<Student>> gradeMap = students.stream().collect(groupingByConcurrent(Student::getGrade));
        System.out.println(gradeMap);


        //对不同分数的学生进行收集分组,自定义分组规则
        ConcurrentMap<Integer, List<Student>> collect = students.stream().collect(groupingByConcurrent(
                //通过函数自定义分组规则
                student -> {
                    int score = student.getScore();
                    if (score >= 90) {
                        return 1;
                    } else if (score >= 70) {
                        return 2;
                    } else {
                        return 3;
                    }
                }));
        System.out.println(collect);
    }

    /**
     * grouping或者groupingByConcurrent结合mapping使用,可以完成各种强大的,几乎满足所有业务需求的功能
     */
    @Test
    public void groupMapping() {

        //对不同等级的学生进行收集分组,使用ArrayList收集同组学生的name
        Map<Integer, List<Integer>> collectName = students.stream().collect(groupingBy(Student::getGrade,
                mapping(Student::getId, toList())));
        System.out.println(collectName);


        //对不同等级的学生进行收集分组,使用Integer收集同组学生的分数的和
        Map<Integer, Integer> collectSum = students.stream().collect(groupingBy(Student::getGrade,
                mapping(Student::getId, reducing(0, Integer::sum))));
        System.out.println(collectSum);

        System.out.println(collectSum);
    }


    List<Student> students = new ArrayList<>();

    @Before
    public void before() {
        students.add(new Student(1, 55, "小花", 4));
        students.add(new Student(2, 100, "小华", 1));
        students.add(new Student(3, 85, "晓华", 2));
        students.add(new Student(4, 70, "肖华", 2));
        students.add(new Student(5, 70, "小小", 2));
        students.add(new Student(6, 66, "小小", 3));
        students.add(new Student(7, 60, "小夏", 3));
        students.add(new Student(8, 77, "花花", 3));
    }


    static class Student {
        private int id;
        private int score;
        private String name;
        private int grade;

        public Integer getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public int getScore() {
            return score;
        }

        public void setScore(int score) {
            this.score = score;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getGrade() {
            return grade;
        }

        public void setGrade(int grade) {
            this.grade = grade;
        }
全文链接:Java8——Stream流的使用(收集操作)

  • 发表于 2020-09-16 16:55
  • 阅读 ( 33 )

0 条评论

请先 登录 后评论
NX小编
NX小编

1158 篇文章

作家榜 »

  1. NX小编 1158 文章
  2. 58沈剑 309 文章
  3. 奈学教育 137 文章
  4. 李希沅 | 奈学教育 36 文章
  5. 江帅帅 | 奈学教育 29 文章
  6. 林淮川 | 奈学教育 12 文章
  7. 科技热点 10 文章
  8. 邱鹏超 2 文章