栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

JDK8的新特性stream——让数据结构更具艺术性

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

JDK8的新特性stream——让数据结构更具艺术性

目录

目标

操作数据

相关依赖

中间方法

distinct

filter

map

flatMap

limit

skip

sorted

终止方法

allMatch

anyMatch

collect

findAny

findFirst

forEach

max/min

noneMatch

reduce

Collectors的方法

averaging

collectingAndThen

countIng

groupingBy

joining

mapping

maxBy/minBy

partitioningBy

summarizing

项目下载地址


目标

熟练使用stream操作集合,能通过例题举一反三,合理地将案例融入到实际工作中。


操作数据
package com.stream.data.bean;

import lombok.Data;

@Data
public class Student {
    private String name;
    private int age;
    private boolean sex;
    //语文分数
    private float chineseScore;
    //数学分数
    private float mathScore;

    public Student(String name,int age,boolean sex,float chineseScore,float mathScore){
        this.name=name;
        this.age=age;
        this.sex=sex;
        this.chineseScore=chineseScore;
        this.mathScore=mathScore;
    }
    public Student(String name,int age,boolean sex){
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    public Student(int age){
        this.age=age;
    };

}
package com.stream.data;

import com.stream.data.bean.Student;

import java.util.*;

public class StreamData {
    //姓名集合
    public static List nameList;
    public static List animalList;
    public static List studentInfoList;
    public static List numList;
    public static List numContainNullList;
    public static List numAllNullList;
    public static List numDoubleList;
    public static List fingerGuessingList;
    public static List> studentAchievementList=new ArrayList<>();
    public static String[] nameArr;
    public static Map map=new HashMap<>();
    static {
        map.put("className","123班");
        map.put("classNo","123");
        map.put("stuNo","123456");
        map.put("stuName","张三");
        map.put("courseNo","Chinese");
        map.put("courseName","语文");
        map.put("grade",98.9);
        animalList=Arrays.asList("猫","狗","鸡","鸭");
        nameArr=new String[]{"阿里巴巴","腾讯","字节跳动","爱奇艺"};
        fingerGuessingList=Arrays.asList("石头","剪刀","布");
        nameList = Arrays.asList("张三", null, null, "李四", "李四", "王五", "张三丰", "李明", "陈小东", "小张");
        studentInfoList = Arrays.asList(
                new Student("张三", 12, true),
                new Student("李四", 13, true),
                new Student("王五", 12, false),
                new Student("赵六", 14, true),
                new Student("钱七", 12, false),
                new Student("钱七", 16, false),
                new Student("钱七", 16, false),
                new Student(null, 16, false),
                new Student("", 19, false),
                new Student(null, 16, false)
        );
        numDoubleList = Arrays.asList(1.4, 2.7, 35.4, 6.5, 22.0, 8.2, 3.3, 0.4, 48.9);
        numList = Arrays.asList(1, 2, 3, 6, 22, 8, 3, 0, 48);
        numContainNullList = Arrays.asList(1, null, -3, 6, 22, -8, 3, 0, 48);
        numAllNullList=Arrays.asList(null,null);
        Map studentAchievementMap = new HashMap<>();
        studentAchievementMap.put("className","123班");
        studentAchievementMap.put("classNo","123");
        studentAchievementMap.put("stuNo","123456");
        studentAchievementMap.put("stuName","张三");
        studentAchievementMap.put("courseNo","Chinese");
        studentAchievementMap.put("courseName","语文");
        studentAchievementMap.put("grade",98.9);
        Map studentAchievementMap1 = new HashMap<>();
        studentAchievementMap1.put("className","123班");
        studentAchievementMap1.put("classNo","123");
        studentAchievementMap1.put("stuNo","123456");
        studentAchievementMap1.put("stuName","张三");
        studentAchievementMap1.put("courseNo","Math");
        studentAchievementMap1.put("courseName","数学");
        studentAchievementMap1.put("grade",91.1);
        Map studentAchievementMap2 = new HashMap<>();
        studentAchievementMap2.put("className","123班");
        studentAchievementMap2.put("classNo","123");
        studentAchievementMap2.put("stuNo","123456");
        studentAchievementMap2.put("stuName","张三");
        studentAchievementMap2.put("courseNo","English");
        studentAchievementMap2.put("courseName","英语");
        studentAchievementMap2.put("grade",92.0);

        Map studentAchievementMap3 = new HashMap<>();
        studentAchievementMap3.put("className","123班");
        studentAchievementMap3.put("classNo","123");
        studentAchievementMap3.put("stuNo","123457");
        studentAchievementMap3.put("stuName","李四");
        studentAchievementMap3.put("courseNo","Chinese");
        studentAchievementMap3.put("courseName","语文");
        studentAchievementMap3.put("grade",100);
        Map studentAchievementMap4 = new HashMap<>();
        studentAchievementMap4.put("className","123班");
        studentAchievementMap4.put("classNo","123");
        studentAchievementMap4.put("stuNo","123457");
        studentAchievementMap4.put("stuName","李四");
        studentAchievementMap4.put("courseNo","Math");
        studentAchievementMap4.put("courseName","数学");
        studentAchievementMap4.put("grade",98.5);
        Map studentAchievementMap5 = new HashMap<>();
        studentAchievementMap5.put("className","123班");
        studentAchievementMap5.put("classNo","123");
        studentAchievementMap5.put("stuNo","123457");
        studentAchievementMap5.put("stuName","李四");
        studentAchievementMap5.put("courseNo","English");
        studentAchievementMap5.put("courseName","英语");
        studentAchievementMap5.put("grade",89.0);


        Map studentAchievementMap6 = new HashMap<>();
        studentAchievementMap6.put("className","124班");
        studentAchievementMap6.put("classNo","124");
        studentAchievementMap6.put("stuNo","123458");
        studentAchievementMap6.put("stuName","王五");
        studentAchievementMap6.put("courseNo","Chinese");
        studentAchievementMap6.put("courseName","语文");
        studentAchievementMap6.put("grade",88.5);
        Map studentAchievementMap7 = new HashMap<>();
        studentAchievementMap7.put("className","124班");
        studentAchievementMap7.put("classNo","124");
        studentAchievementMap7.put("stuNo","123458");
        studentAchievementMap7.put("stuName","王五");
        studentAchievementMap7.put("courseNo","Math");
        studentAchievementMap7.put("courseName","数学");
        studentAchievementMap7.put("grade",90.0);
        Map studentAchievementMap8 = new HashMap<>();
        studentAchievementMap8.put("className","124班");
        studentAchievementMap8.put("classNo","124");
        studentAchievementMap8.put("stuNo","123458");
        studentAchievementMap8.put("stuName","王五");
        studentAchievementMap8.put("courseNo","English");
        studentAchievementMap8.put("courseName","英语");
        studentAchievementMap8.put("grade",95.0);

        Map studentAchievementMap9 = new HashMap<>();
        studentAchievementMap9.put("className","124班");
        studentAchievementMap9.put("classNo","124");
        studentAchievementMap9.put("stuNo","123459");
        studentAchievementMap9.put("stuName","赵六");
        studentAchievementMap9.put("courseNo","Chinese");
        studentAchievementMap9.put("courseName","语文");
        studentAchievementMap9.put("grade",99.5);
        Map studentAchievementMap10 = new HashMap<>();
        studentAchievementMap10.put("className","124班");
        studentAchievementMap10.put("classNo","124");
        studentAchievementMap10.put("stuNo","123459");
        studentAchievementMap10.put("stuName","赵六");
        studentAchievementMap10.put("courseNo","Math");
        studentAchievementMap10.put("courseName","数学");
        studentAchievementMap10.put("grade",81.5);
        Map studentAchievementMap11 = new HashMap<>();
        studentAchievementMap11.put("className","124班");
        studentAchievementMap11.put("classNo","124");
        studentAchievementMap11.put("stuNo","123459");
        studentAchievementMap11.put("stuName","赵六");
        studentAchievementMap11.put("courseNo","English");
        studentAchievementMap11.put("courseName","英语");
        studentAchievementMap11.put("grade",80.0);

        studentAchievementList.add(studentAchievementMap);
        studentAchievementList.add(studentAchievementMap1);
        studentAchievementList.add(studentAchievementMap2);
        studentAchievementList.add(studentAchievementMap3);
        studentAchievementList.add(studentAchievementMap4);
        studentAchievementList.add(studentAchievementMap5);
        studentAchievementList.add(studentAchievementMap6);
        studentAchievementList.add(studentAchievementMap7);
        studentAchievementList.add(studentAchievementMap8);
        studentAchievementList.add(studentAchievementMap9);
        studentAchievementList.add(studentAchievementMap10);
        studentAchievementList.add(studentAchievementMap11);
    }
}

相关依赖
    
        
            com.alibaba
            fastjson
            1.2.47
        
        
            commons-lang
            commons-lang
            2.6
        

        
            org.apache.commons
            commons-collections4
            4.4
        
        
        
            com.google.code.gson
            gson
            2.8.6
        
        
            com.alibaba
            fastjson
            1.2.75
        

        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.projectlombok
            lombok
            true
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
        
            com.vaadin.external.google
            android-json
            0.0.20131108.vaadin1
            compile
        
    

中间方法

distinct

作用:过滤重复数据。

需求一:过滤集合中重复的姓名。

方案:

    public static void distinctName() {
        List nameList = StreamData.nameList;
        System.out.println("原来的集合:"+nameList);
        List list = nameList.stream().distinct().collect(
                Collectors.toList()
        );
        System.out.println("现在的集合:"+list);
    }

返回结果:

原来的集合:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
现在的集合:[张三, null, 李四, 王五, 张三丰, 李明, 陈小东, 小张]

需求二:根据姓名,过滤掉重复的数据。

方案:

    public static  Predicate distinct(Function keyExtractor) {
        Set seen = ConcurrentHashMap.newKeySet();
        return t -> seen.add(
                keyExtractor.apply(t)
        );
    }
    
    public static void distinctStudentByName() {
        List studentInfoList = StreamData.studentInfoList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(studentInfoList));
        System.out.println(array);
        List collect = studentInfoList.stream().filter(
                distinct(
                        stu -> {
                            if (StringUtils.isBlank(stu.getName())) {
                                stu.setName("null");
                            }
                            return stu.getName();
                        }
                )
        ).collect(
                Collectors.toList()
        );
        JSONArray collectJson = JSONArray.parseArray(JSON.toJSONString(collect));
        System.out.println(collectJson);
    }

    
    public static void distinctBean() {
        List studentInfoList = StreamData.studentInfoList;
        ArrayList list = studentInfoList.stream().collect(
                Collectors.collectingAndThen(
                        Collectors.toCollection(
                                () -> new TreeSet<>(
                                        Comparator.comparing(
                                                p -> {
                                                    if (StringUtils.isBlank(p.getName())){
                                                        p.setName("null");
                                                    }
                                                    return p.getName();
                                                }
                                        )
                                )
                        ),
                        ArrayList::new
                )
        );
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
    } 

原始数据:

[
    {
        "sex": true, 
        "name": "张三", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "李四", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 13
    }, 
    {
        "sex": false, 
        "name": "王五", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "赵六", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 14
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 19
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }
]

返回结果:

[
    {
        "sex": true, 
        "name": "张三", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "李四", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 13
    }, 
    {
        "sex": false, 
        "name": "王五", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "赵六", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 14
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": false, 
        "name": "null", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }
]

filter

作用:过滤掉不符合条件的数据。

需求一:筛选出集合中名字里有”张“的数据。

方案:

    public static void containsName() {
        List nameList = StreamData.nameList;
        System.out.println("初始的数据:"+nameList);
        List list = nameList.stream().filter(
                str -> StringUtils.isNotBlank(str)  && str.contains("张")
        ).collect(
                Collectors.toList()
        );
        System.out.println("过滤后的数据:"+list);
    }

返回结果:

初始的数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
过滤后的数据:[张三, 张三丰, 小张]

需求二:筛选出集合中姓“张”的数据。

方案:

    public static void containsName2() {
        List nameList = StreamData.nameList;
        System.out.println("初始的数据:"+nameList);
        List list = nameList.stream().filter(
                str -> StringUtils.isNotBlank(str)  && "张".equals(str.substring(0,1))
        ).collect(
                Collectors.toList()
        );
        System.out.println("过滤后的数据:"+list);
    }

返回结果:

初始的数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
过滤后的数据:[张三, 张三丰]

需求三:过滤掉集合中18岁以下的学生。

方案:

    public static void containsName3() {
        List studentInfoList=StreamData.studentInfoList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(studentInfoList));
        System.out.println(array);
        List studentFilterList = studentInfoList.stream().filter(
                student -> student.getAge() > 18
        ).collect(
                Collectors.toList()
        );
        JSONArray array2 = JSONArray.parseArray(JSON.toJSONString(studentFilterList));
        System.out.println(array2);
    }

原始数据:

[
    {
        "sex": true, 
        "name": "张三", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "李四", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 13
    }, 
    {
        "sex": false, 
        "name": "王五", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "赵六", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 14
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 19
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }
]

返回结果:

[
    {
        "sex": false, 
        "name": "", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 19
    }
]

map

作用:对流中所有元素做统一处理。

需求一:取出学生集合中的所有人的姓名,并在姓名前加“123班_”前缀。

方案:

    public static void updateBean() {
        List studentInfoList = StreamData.studentInfoList;
        List list = studentInfoList.stream().map(
                stu-> "123班_"+stu.getName()
        ).collect(Collectors.toList());
        System.out.println(list);
    }

返回结果:

[123班_张三, 123班_李四, 123班_王五, 123班_赵六, 123班_钱七, 123班_钱七, 123班_钱七, 123班_null, 123班_, 123班_null]

flatMap

作用:把集合内容扁平化。

需求一:拆分集合中的每个元素。

方案:

    
    public static void flatMapTest() {
        List nameList = StreamData.nameList;
        System.out.println("原来的数据:"+nameList);
        List collect = nameList.stream().flatMap(
                str -> {
                    if (StringUtils.isBlank(str)) {
                        str = "";
                    }
                    Stream sorted = Arrays.stream(str.split(""));
                    return sorted;
                }
        ).collect(
                Collectors.toList()
        );
        System.out.println("处理后的数据:"+collect);
    }

返回结果:

原来的数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
处理后的数据:[张, 三, , , 李, 四, 李, 四, 王, 五, 张, 三, 丰, 李, 明, 陈, 小, 东, 小, 张]

需求二:两次猜拳,石头/剪刀/布一共有多少种组合。

方案:

    
    public static void flatMapTest2() {
        List list = StreamData.fingerGuessingList;
        List> collect = list.stream().flatMap(
                item -> list.stream().map(
                        item2 -> Arrays.asList(item, item2)
                )
        ).collect(
                Collectors.toList()
        );
        System.out.println(collect);
    }

返回结果:

[[石头, 石头], [石头, 剪刀], [石头, 布], [剪刀, 石头], [剪刀, 剪刀], [剪刀, 布], [布, 石头], [布, 剪刀], [布, 布]]

limit

作用:获取流中前n条数据。

需求一:获取集合中前2条数据。

方案:

    
    public static void limit() {
        List nameList = StreamData.nameList;
        System.out.println("初始数据"+nameList);
        List list = nameList.stream().limit(2).collect(Collectors.toList());
        System.out.println("结果数据"+list);
    }

返回结果:

初始数据[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
结果数据[张三, null]

skip

作用:跳过流中前n条数据。

需求一:跳过流中前2条数据。

方案:

    
    public static void skip() {
        List nameList = StreamData.nameList;
        System.out.println("原来的集合:"+nameList);
        List list = nameList.stream().skip(2).collect(Collectors.toList());
        System.out.println("现在的集合:"+list);
    }

返回结果:

原来的集合:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
结果数据:[null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]

sorted

作用:对流排序(默认升序)。

需求一:升序排序集合的元素。

方案:

    
    public static void ascList() {
        List numList = StreamData.numList;
        System.out.println("原来的集合:"+numList);
        List list = numList.stream().sorted().collect(Collectors.toList());
        System.out.println("结果数据:"+list);
    }

返回结果:

原来的集合:[1, 2, 3, 6, 22, 8, 3, 0, 48]
结果数据:[0, 1, 2, 3, 3, 6, 8, 22, 48]

需求二:降序序排序集合的元素。

方案:

    
    public static void descList() {
        List numList = StreamData.numList;
        System.out.println("原来的集合:"+numList);
        List list = numList.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        System.out.println("结果数据:"+list);
    }

返回结果:

原来的集合:[1, 2, 3, 6, 22, 8, 3, 0, 48]
结果数据:[48, 22, 8, 6, 3, 3, 2, 1, 0]

需求三:中文排序,中文姓氏生母升序排序,如果是姓名为null,则排序到最后面。

方案:

    
    public static void sortNameAsc() {
        List nameList = StreamData.nameList;
        System.out.println("原来的集合:" + nameList);
        List list = nameList.stream().sorted(
                Comparator.nullsLast(
                        Collator.getInstance(Locale.CHINA)
                )
        ).collect(
                Collectors.toList()
        );
        System.out.println("结果数据:"+list);
    }

返回结果:

原来的集合:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
结果数据:[陈小东, 李明, 李四, 李四, 王五, 小张, 张三, 张三丰, null, null]

需求四:中文排序,中文姓氏生母降序排序,如果是姓名为null,则排序到最后面。

方案:

    
    public static void sortNameDesc() {
        List nameList = StreamData.nameList;
        System.out.println("原来的集合:" + nameList);
        List list = nameList.stream().sorted(
                Comparator.nullsLast(
                        Collections.reverseOrder(Collator.getInstance(Locale.CHINA))
                )
        ).collect(Collectors.toList());
        System.out.println("结果数据:"+list);
    }

返回结果:

原来的集合:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
结果数据:[张三丰, 张三, 小张, 王五, 李四, 李四, 李明, 陈小东, null, null]

终止方法

allMatch

作用:检查流中所有元素是否匹配。都匹配返回true,有一个不匹配返回false。与noneMatch相反。

需求一:检查集合是否所有元素不为空。

方案:

    
    public static void check() {
        List list = StreamData.nameList;
        System.out.println("原始数据:"+list);
        boolean boo = list.stream().allMatch(
                name -> StringUtils.isNotBlank(name)
        );
        System.out.println("返回结果:"+boo);
    }

返回结果:

原始数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
返回结果:false

需求二:检查学生集合中是否学生都小于18岁。

方案:

    
    public static void check2() {
        List list = StreamData.studentInfoList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println("原始数据:"+array);
        boolean boo = list.stream().allMatch(
                student -> student != null &&student.getAge()<18
        );
        System.out.println("返回结果:"+boo);
    }

原始数据:

[
    {
        "sex": true, 
        "name": "张三", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "李四", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 13
    }, 
    {
        "sex": false, 
        "name": "王五", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "赵六", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 14
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 19
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }
]

返回结果:

返回结果:false

anyMatch

作用:检查流中是否至少有一个元素匹配。

需求一:检查集合中是否有叫“张三”的人。

方案:

    
    public static void check() {
        List list = StreamData.nameList;
        System.out.println("原始数据:"+list);
        boolean boo = list.stream().anyMatch(
                name -> StringUtils.isBlank(name) ? false : "张三".equals(name)
        );
        System.out.println("返回结果:"+boo);
    }

返回结果:

原始数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
返回结果:true

collect

作用:收集器,将流转换为指定格式。

需求一:将数组转换成List。

方案:

    
    public static void toList(){
        String[] nameArr=StreamData.nameArr;
        System.out.println("原始数据:");
        for (String s : nameArr) {
            System.out.println(s);
        }
        List list = Arrays.stream(nameArr).collect(Collectors.toList());
        System.out.println("返回结果:"+list);
    }

返回结果:

原始数据:
阿里巴巴
腾讯
字节跳动
爱奇艺
返回结果:[阿里巴巴, 腾讯, 字节跳动, 爱奇艺]

需求二:将数List转换成Set。

方案:

    
    public static void toSet(){
        List list=StreamData.nameList;
        System.out.println("原始数据:"+list);
        Set set = list.stream().collect(Collectors.toSet());
        System.out.println("返回结果:"+set);
    }

返回结果:

原始数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
返回结果:[null, 李四, 张三, 王五, 张三丰, 陈小东, 小张, 李明]

需求三:将数List转换成Map。

方案:

    
    public static void toMap(){
        List list=StreamData.nameList;
        System.out.println("原始数据:"+list);
        Map map = list.stream().collect(
                Collectors.toMap(
                        //设置key
                key -> UUID.randomUUID()+"",
                        //设置value
                        value -> StringUtils.isNotBlank(value)?value:"",
                        //如果key重复则新的覆盖旧的。
                        (oldValue, newValue) -> newValue
        ));
        JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
        System.out.println("结果数据:"+json);
    }

返回结果:

原始数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
结果数据:
{
    "e436fdd9-e7f1-4078-874a-be4c2e115fde": "李四", 
    "33075304-e1b5-4a22-bb82-f99122b46f12": "小张", 
    "6373dc53-f231-4bc9-a69b-596561712ee7": "陈小东", 
    "f0cfddcc-d8c2-4504-a62b-ce7c59faaf1b": "", 
    "6f67d905-1d5b-417f-a1ad-997e5370ef72": "李四", 
    "aff28097-6dc8-4b86-a58c-4fdfbec96c7d": "张三", 
    "766de379-a8d1-4afe-aaeb-8a0142c74977": "王五", 
    "c9223180-3100-4b42-8e44-0b67c151982d": "", 
    "7632ffa0-216f-41ce-873a-ce6764d1a359": "张三丰", 
    "4c5918dc-b00d-49ca-b9a5-486227a1a30b": "李明"
}

findAny

作用:返回流中一个元素。如果是串行流操作则回流中的第一个元素。如果是并行流操作则返回随机一个元素。

需求一:串行流,返回一个元素。

方案:

    
    public static void returnOne() {
        List list = StreamData.nameList;
        Optional any = list.stream().findAny();
        if (any.isPresent()) {
            System.out.println(any.get());
        }
    }

返回结果:

张三

需求二:并行流,返回一个元素。

方案:

    
    public static void returnOne2() {
        List list = StreamData.numList;
        Optional any = list.parallelStream().findAny();
        if (any.isPresent()) {
            System.out.println(any.get());
        }
    }

返回结果:

8

findFirst

作用:返回流中第一个元素。

需求一:返回流中第一个元素。

方案:

    public static void returnOne() {
        List list = StreamData.nameList;
        System.out.println("原始数据:"+list);
        Optional any = list.stream().findFirst();
        if (any.isPresent()) {
            System.out.println("返回结果:"+any.get());
        }
    }

返回结果:

原始数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
返回结果:张三

forEach

作用:循环集合。

需求一:循环List。

方案:

    
    public static void forEach(){
        List list=StreamData.nameList;
        list.stream().forEach(name-> System.out.println(name));
    }
    
    public static void forEach2(){
        List list=StreamData.nameList;
        list.stream().forEach(System.out::println);
    }

返回结果:

张三
null
null
李四
李四
王五
张三丰
李明
陈小东
小张

需求二:循环Map。

方案:

    
    public static void forEach3(){
        Map map = StreamData.map;
        map.forEach((k,v)-> System.out.println(k+"="+v));
    }

返回结果:

courseName=语文
courseNo=Chinese
grade=98.9
classNo=123
className=123班
stuName=张三
stuNo=123456

max/min

作用:取出流中最大/最小的元素。这里只演示max方法,min方法大家以此类推。

需求一:取出集合中最大的数。

方案:

    
    public static void maxNum(){
        List list=StreamData.numList;
        System.out.println("原始数据:"+list);
        Optional max = list.stream().max(
                Integer::compare
        );
        if(max.isPresent()){
            System.out.println("返回结果:"+max.get());
        }
    }
    
    public static void maxNum2(){
        List list=StreamData.numList;
        System.out.println(list);
        Optional max = list.stream().max(
                (iterator,item)-> iterator.compareTo(item)
        );
        if(max.isPresent()){
            System.out.println(max.get());
        }
    }

    
    public static void maxNum3(){
        //这个集合中元素都为null。
        //List list=StreamData.numAllNullList;
        //这个集合中部分元素为null。
        List list=StreamData.numContainNullList;
        System.out.println("原始数据:"+list);
        boolean b = list.stream().allMatch(
                num -> num == null
        );
        if(b){
            System.out.println("集合中最大元素为:"+null);
            return;
        }
        Optional max = list.stream().max(
                (iterator,item)-> {
                    if(item==null){
                        return 1;
                    }
                    if(iterator==null){
                        return -1;
                    }
                    return iterator.compareTo(item);
                }
        );
        if(max.isPresent()){
            System.out.println("结果数据:"+max.get());
        }
    }

noneMatch

作用:检查流中所有元素是否都不匹配,都不匹配返回true,有一个匹配返回false。与allMatch相反。

需求一:检查集合中所有元素是否都不为空。每个元素都是空,则返回true,否则返回false。

方案:

    
    public static void check() {
        List list = StreamData.nameList;
        System.out.println("原始数据:"+list);
        boolean boo = list.stream().noneMatch(
                name -> StringUtils.isNotBlank(name)
        );
        System.out.println("结果数据:"+boo);
    }

返回结果:

原始数据:[张三, null, null, 李四, 李四, 王五, 张三丰, 李明, 陈小东, 小张]
结果数据:false

需求二:检查学生集合中是否学生都不小于18岁。都不小于18岁返回true,有一个学生小于18岁返回false。

方案:

    
    public static void check2() {
        List list = StreamData.studentInfoList;
        System.out.println(list);
        boolean boo = list.stream().noneMatch(
                student -> student != null &&student.getAge()<18
        );
        System.out.println(boo);
    }

原始数据:

[
    {
        "sex": true, 
        "name": "张三", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "李四", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 13
    }, 
    {
        "sex": false, 
        "name": "王五", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "赵六", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 14
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 19
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }
]

返回结果:

false

reduce

作用:将流中的元素反复使用得到结果。

需求一:求集合中所有数的和。

方案:

    
    public static void sum(){
       List list=StreamData.numList;
        System.out.println("原始数据:"+list);
        Optional reduce = list.stream().reduce(
                //accumulator表示最终结果,和item类型一样。
                //item表示集合的元素
                (accumulator, item) -> accumulator + item
                
        );
        if(reduce.isPresent()){
            System.out.println("返回结果:"+reduce.get());
        }
    }

返回结果:

原始数据:[1, 2, 3, 6, 22, 8, 3, 0, 48]
返回结果:93

需求二:求所有学生的年龄之和。

方案:

    
    public static void sum2(){
        List list=StreamData.studentInfoList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Optional reduce = list.stream().reduce(
                //accumulator表示最终结果,和item类型一样。
                //item表示集合的元素
                (accumulator,item) -> {
                    accumulator.setAge(accumulator.getAge()+item.getAge());
                    return accumulator;
                }
        );
        if(reduce.isPresent()){
            System.out.println("年龄总和:"+reduce.get().getAge());
        }
    }

原始数据:

[
    {
        "sex": true, 
        "name": "张三", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "李四", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 13
    }, 
    {
        "sex": false, 
        "name": "王五", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "赵六", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 14
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 19
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }
]

返回结果:

年龄总和:146

Collectors的方法

averaging

作用:求平均数。

需求一:求平均数。

方案:

    
    public static void averaging() {
        List list = StreamData.numList;
        Double avg = list.stream().collect(
                Collectors.averagingInt(a->a)
        );
        System.out.println(avg);
    }

    
    public static void averaging2() {
        List list = StreamData.numDoubleList;
        Double avg = list.stream().collect(
                Collectors.averagingDouble(a->a)
        );
        System.out.println(avg);
    }

collectingAndThen

作用:先对数据进行处理,处理之后再对各个分量进行处理,我个人觉得该方法和mysql的窗口函数极为相似。

需求一:求平均值,将返回平均值*10。

方案:

    
    public static void collectingAndThen() {
        List list = StreamData.numList;
        Double tenAvg = list.stream().collect(
                Collectors.collectingAndThen(
                        //第一部分
                        Collectors.averagingLong(num -> {
                                    return num;
                                }
                        ),
                        //第二部分(avgNum是上一个步骤的值。)
                        avgNum -> {
                            return avgNum * 10;
                        }
                )
        );
        System.out.println(tenAvg);
    }

需求二:求出集合中小于10的数,将小于10的数加10。

方案:

    
    public static void collectingAndThen2() {
        List list = StreamData.numList;
        List ltTenList = list.stream().collect(
                Collectors.collectingAndThen(
                        //第一部分(将大于等于10和小于10的数分割成两个集合。)
                        Collectors.partitioningBy(
                                num -> num >= 10
                        ),
                        //第二部分
                        numMap -> {
                            if (numMap.get(false) != null && numMap.get(false).size() > 0) {
                                List falseList = numMap.get(false).stream().map(
                                        num -> num != null ? num + 10 : 10
                                ).collect(Collectors.toList());
                                return falseList;
                            }
                            return new ArrayList<>();
                        }
                )
        );
        System.out.println(ltTenList);
    }

需求三:把相同班级的学生统计在一起,计算每个学生的平均成绩。

需求四:把相同班级的学生统计在一起,计算每个学生的各科目的成绩。大于等于60合格,小于60分不合格。

方案:这两个需求稍微复杂一点,且用到了groupingBy方法,大家可以在本篇博客中的groupingBy目录中去找这两个需求的解答方案,这里不赘述。


countIng

作用:统计元素数量。

需求一:统计元素数量。

方案:

    
    public static void countIng(){
        List list=StreamData.numList;
        System.out.println("初始数据:"+list);
        Long count = list.stream().collect(
                Collectors.counting()
        );
        System.out.println("元素数量:"+count);
    }

结果数据:

初始数据:[1, 2, 3, 6, 22, 8, 3, 0, 48]
元素数量:9

需求二:统计全班考试成绩超过90分的成绩数量。

方案:

    
    public static void countIng2(){
        List> list=StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Long count=list.stream().filter(
                stu->Double.parseDouble(stu.get("grade").toString())>90
        ).collect(
                Collectors.counting()
        );
        System.out.println("结果数据:"+count);
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

结果数据:7

groupingBy

作用:按照指定的规则对数据进行分组。

需求一:把相同班级的学生分数记录统计在一起。

方案:

    
    public static void group() {
        List> list = StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Map>> map = list.stream().collect(Collectors.groupingBy(g -> g.get("classNo").toString()));
        JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
        System.out.println(json);
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

{
    "123": [
        {
            "courseName": "语文", 
            "courseNo": "Chinese", 
            "grade": 98.9, 
            "classNo": "123", 
            "className": "123班", 
            "stuName": "张三", 
            "stuNo": "123456"
        }, 
        {
            "courseName": "数学", 
            "courseNo": "Math", 
            "grade": 91.1, 
            "classNo": "123", 
            "className": "123班", 
            "stuName": "张三", 
            "stuNo": "123456"
        }, 
        {
            "courseName": "英语", 
            "courseNo": "English", 
            "grade": 92, 
            "classNo": "123", 
            "className": "123班", 
            "stuName": "张三", 
            "stuNo": "123456"
        }, 
        {
            "courseName": "语文", 
            "courseNo": "Chinese", 
            "grade": 100, 
            "classNo": "123", 
            "className": "123班", 
            "stuName": "李四", 
            "stuNo": "123457"
        }, 
        {
            "courseName": "数学", 
            "courseNo": "Math", 
            "grade": 98.5, 
            "classNo": "123", 
            "className": "123班", 
            "stuName": "李四", 
            "stuNo": "123457"
        }, 
        {
            "courseName": "英语", 
            "courseNo": "English", 
            "grade": 89, 
            "classNo": "123", 
            "className": "123班", 
            "stuName": "李四", 
            "stuNo": "123457"
        }
    ], 
    "124": [
        {
            "courseName": "语文", 
            "courseNo": "Chinese", 
            "grade": 88.5, 
            "classNo": "124", 
            "className": "124班", 
            "stuName": "王五", 
            "stuNo": "123458"
        }, 
        {
            "courseName": "数学", 
            "courseNo": "Math", 
            "grade": 90, 
            "classNo": "124", 
            "className": "124班", 
            "stuName": "王五", 
            "stuNo": "123458"
        }, 
        {
            "courseName": "英语", 
            "courseNo": "English", 
            "grade": 95, 
            "classNo": "124", 
            "className": "124班", 
            "stuName": "王五", 
            "stuNo": "123458"
        }, 
        {
            "courseName": "语文", 
            "courseNo": "Chinese", 
            "grade": 99.5, 
            "classNo": "124", 
            "className": "124班", 
            "stuName": "赵六", 
            "stuNo": "123459"
        }, 
        {
            "courseName": "数学", 
            "courseNo": "Math", 
            "grade": 81.5, 
            "classNo": "124", 
            "className": "124班", 
            "stuName": "赵六", 
            "stuNo": "123459"
        }, 
        {
            "courseName": "英语", 
            "courseNo": "English", 
            "grade": 80, 
            "classNo": "124", 
            "className": "124班", 
            "stuName": "赵六", 
            "stuNo": "123459"
        }
    ]
}

需求二:把相同班级的学生统计在一起,只返回学号和姓名。

方案:

    
    public static void group2() {
        List> list = StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Map>> map = list.stream().collect(
                Collectors.groupingBy(
                        g -> g.get("classNo").toString(),
                        Collectors.mapping(stu ->
                                        new HashMap() {
                                            {
                                                put("stuNo", stu.get("stuNo").toString());
                                                put("stuName", stu.get("stuName").toString());
                                            }
                                        },
                                Collectors.toSet()
                        )
                )
        );
        JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
        System.out.println(json);
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

{
    "123": [
        {
            "stuName": "张三", 
            "stuNo": "123456"
        }, 
        {
            "stuName": "李四", 
            "stuNo": "123457"
        }
    ], 
    "124": [
        {
            "stuName": "王五", 
            "stuNo": "123458"
        }, 
        {
            "stuName": "赵六", 
            "stuNo": "123459"
        }
    ]
}

需求三:求出每个班级的平均成绩。

方案:

    
    public static void group3() {
        List> list = StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Map map = list.stream().collect(
                Collectors.groupingBy(
                        //根据班级分组
                        record -> record.get("classNo"),
                        //对分组后的结果集二次处理
                        Collectors.averagingDouble(
                                record -> Double.parseDouble(record.get("grade").toString())
                        )
                )
        );
        JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
        System.out.println(json);
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

{
    "123": 94.91666666666667, 
    "124": 89.08333333333333
}

需求四:把相同班级的学生统计在一起,且学生以学号分组统计成绩。

方案:

    
    public static void group4() {
        List> list = StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Map>>> map =
                list.stream().collect(
                        Collectors.groupingBy(
                                //根据班级分组
                                record -> record.get("classNo"),
                                //对分组后的结果集二次处理
                                Collectors.groupingBy(
                                        record -> record.get("stuNo")
                                )
                        )
                );
        JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
        System.out.println(json);
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

{
    "123": {
        "123456": [
            {
                "courseName": "语文", 
                "courseNo": "Chinese", 
                "grade": 98.9, 
                "classNo": "123", 
                "className": "123班", 
                "stuName": "张三", 
                "stuNo": "123456"
            }, 
            {
                "courseName": "数学", 
                "courseNo": "Math", 
                "grade": 91.1, 
                "classNo": "123", 
                "className": "123班", 
                "stuName": "张三", 
                "stuNo": "123456"
            }, 
            {
                "courseName": "英语", 
                "courseNo": "English", 
                "grade": 92, 
                "classNo": "123", 
                "className": "123班", 
                "stuName": "张三", 
                "stuNo": "123456"
            }
        ], 
        "123457": [
            {
                "courseName": "语文", 
                "courseNo": "Chinese", 
                "grade": 100, 
                "classNo": "123", 
                "className": "123班", 
                "stuName": "李四", 
                "stuNo": "123457"
            }, 
            {
                "courseName": "数学", 
                "courseNo": "Math", 
                "grade": 98.5, 
                "classNo": "123", 
                "className": "123班", 
                "stuName": "李四", 
                "stuNo": "123457"
            }, 
            {
                "courseName": "英语", 
                "courseNo": "English", 
                "grade": 89, 
                "classNo": "123", 
                "className": "123班", 
                "stuName": "李四", 
                "stuNo": "123457"
            }
        ]
    }, 
    "124": {
        "123458": [
            {
                "courseName": "语文", 
                "courseNo": "Chinese", 
                "grade": 88.5, 
                "classNo": "124", 
                "className": "124班", 
                "stuName": "王五", 
                "stuNo": "123458"
            }, 
            {
                "courseName": "数学", 
                "courseNo": "Math", 
                "grade": 90, 
                "classNo": "124", 
                "className": "124班", 
                "stuName": "王五", 
                "stuNo": "123458"
            }, 
            {
                "courseName": "英语", 
                "courseNo": "English", 
                "grade": 95, 
                "classNo": "124", 
                "className": "124班", 
                "stuName": "王五", 
                "stuNo": "123458"
            }
        ], 
        "123459": [
            {
                "courseName": "语文", 
                "courseNo": "Chinese", 
                "grade": 99.5, 
                "classNo": "124", 
                "className": "124班", 
                "stuName": "赵六", 
                "stuNo": "123459"
            }, 
            {
                "courseName": "数学", 
                "courseNo": "Math", 
                "grade": 81.5, 
                "classNo": "124", 
                "className": "124班", 
                "stuName": "赵六", 
                "stuNo": "123459"
            }, 
            {
                "courseName": "英语", 
                "courseNo": "English", 
                "grade": 80, 
                "classNo": "124", 
                "className": "124班", 
                "stuName": "赵六", 
                "stuNo": "123459"
            }
        ]
    }
}

需求五:把相同班级的学生统计在一起,计算每个学生的平均成绩。

方案:

    
    public static void group5() {
        List> list = StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Map> map = list.stream().collect(
                Collectors.groupingBy(
                        //根据班级分组
                        record -> record.get("classNo"),
                        //对分组后的结果集二次处理
                        Collectors.groupingBy(
                                record -> record.get("stuNo"),
                                //对分组后的结果集三次处理
                                Collectors.averagingDouble(
                                        grade -> Double.parseDouble(grade.get("grade").toString())
                                )
                        )
                )
        );
        JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
        System.out.println(json);
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

{
    "123": {
        "123456": 94, 
        "123457": 95.83333333333333
    }, 
    "124": {
        "123458": 91.16666666666667, 
        "123459": 87
    }
}

需求六:把相同班级的学生统计在一起,计算每个学生的各科目的成绩。大于等于60合格,小于60分不合格。

方案:

   
    public static void group6() {
        List> list = StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Map>> result = list.stream().collect(
                Collectors.groupingBy(
                        //根据班级分组
                        record -> record.get("classNo"),
                        //对分组后的结果集二次处理(根据学号分组)
                        Collectors.groupingBy(
                                record -> record.get("stuNo") + "_" + record.get("stuName"),
                                //对分组后的结果集三次处理(把平均分大于90的学生筛选出来。)
                                Collectors.collectingAndThen(
                                        Collectors.partitioningBy(
                                                grade -> Double.parseDouble(grade.get("grade").toString()) >= 60
                                        ),
                                        gradeMap -> {
                                            Map m = new HashMap<>();
                                            if (gradeMap != null && gradeMap.size() > 0) {
                                                //如果题目只要求返回不合格或者合格的科目,则只需要添加一个map。
                                                m.put("不合格", gradeMap.get(false));
                                                m.put("合格", gradeMap.get(true));
                                                return m;
                                            }
                                            return new HashMap<>();
                                        }
                                )
                        )
                )
        );
        JSONObject json = JSONObject.parseObject(JSON.toJSONString(result));
        System.out.println(json);
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

{
    "123": {
        "123457_李四": {
            "不合格": [ ], 
            "合格": [
                {
                    "courseName": "语文", 
                    "courseNo": "Chinese", 
                    "grade": 100, 
                    "classNo": "123", 
                    "className": "123班", 
                    "stuName": "李四", 
                    "stuNo": "123457"
                }, 
                {
                    "courseName": "数学", 
                    "courseNo": "Math", 
                    "grade": 98.5, 
                    "classNo": "123", 
                    "className": "123班", 
                    "stuName": "李四", 
                    "stuNo": "123457"
                }, 
                {
                    "courseName": "英语", 
                    "courseNo": "English", 
                    "grade": 89, 
                    "classNo": "123", 
                    "className": "123班", 
                    "stuName": "李四", 
                    "stuNo": "123457"
                }
            ]
        }, 
        "123456_张三": {
            "不合格": [ ], 
            "合格": [
                {
                    "courseName": "语文", 
                    "courseNo": "Chinese", 
                    "grade": 98.9, 
                    "classNo": "123", 
                    "className": "123班", 
                    "stuName": "张三", 
                    "stuNo": "123456"
                }, 
                {
                    "courseName": "数学", 
                    "courseNo": "Math", 
                    "grade": 91.1, 
                    "classNo": "123", 
                    "className": "123班", 
                    "stuName": "张三", 
                    "stuNo": "123456"
                }, 
                {
                    "courseName": "英语", 
                    "courseNo": "English", 
                    "grade": 92, 
                    "classNo": "123", 
                    "className": "123班", 
                    "stuName": "张三", 
                    "stuNo": "123456"
                }
            ]
        }
    }, 
    "124": {
        "123458_王五": {
            "不合格": [ ], 
            "合格": [
                {
                    "courseName": "语文", 
                    "courseNo": "Chinese", 
                    "grade": 88.5, 
                    "classNo": "124", 
                    "className": "124班", 
                    "stuName": "王五", 
                    "stuNo": "123458"
                }, 
                {
                    "courseName": "数学", 
                    "courseNo": "Math", 
                    "grade": 90, 
                    "classNo": "124", 
                    "className": "124班", 
                    "stuName": "王五", 
                    "stuNo": "123458"
                }, 
                {
                    "courseName": "英语", 
                    "courseNo": "English", 
                    "grade": 95, 
                    "classNo": "124", 
                    "className": "124班", 
                    "stuName": "王五", 
                    "stuNo": "123458"
                }
            ]
        }, 
        "123459_赵六": {
            "不合格": [ ], 
            "合格": [
                {
                    "courseName": "语文", 
                    "courseNo": "Chinese", 
                    "grade": 99.5, 
                    "classNo": "124", 
                    "className": "124班", 
                    "stuName": "赵六", 
                    "stuNo": "123459"
                }, 
                {
                    "courseName": "数学", 
                    "courseNo": "Math", 
                    "grade": 81.5, 
                    "classNo": "124", 
                    "className": "124班", 
                    "stuName": "赵六", 
                    "stuNo": "123459"
                }, 
                {
                    "courseName": "英语", 
                    "courseNo": "English", 
                    "grade": 80, 
                    "classNo": "124", 
                    "className": "124班", 
                    "stuName": "赵六", 
                    "stuNo": "123459"
                }
            ]
        }
    }
}

joining

作用:按照指定的格式拼接数据。

需求一:拼接流中的所有字符串。

方案:

    
    public static void joining() {
        List list = StreamData.animalList;
        System.out.println("原始数据:"+list);
        String str = list.stream().collect(
                Collectors.joining()
        );
        System.out.println("返回结果:"+str);
    }

返回结果:

原始数据:[猫, 狗, 鸡, 鸭]
返回结果:猫狗鸡鸭

需求二:拼接流中的所有字符串,用逗号分开。

方案:

    
    public static void joining2() {
        List list = StreamData.animalList;
        System.out.println("原始数据:"+list);
        String str = list.stream().collect(
                Collectors.joining(",")
        );
        System.out.println("返回结果:"+str);
    }

返回结果:

原始数据:[猫, 狗, 鸡, 鸭]
返回结果:猫,狗,鸡,鸭

需求三:拼接流中的所有字符串,用逗号分开,用大括号包裹。

方案:

    
    public static void joining3() {
        List list = StreamData.animalList;
        System.out.println("原始数据:"+list);
        String str = list.stream().collect(
                Collectors.joining(",","{","}")
        );
        System.out.println("返回结果:"+str);
    }

返回结果:

原始数据:[猫, 狗, 鸡, 鸭]
返回结果:{猫,狗,鸡,鸭}

mapping

作用:抽取需要的属性,定义返回格式。

需求一:求所有参加考试的学生的学号。

方案:

    
    public static void mapping() {
        List> list = StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Set set = list.stream().collect(
                Collectors.mapping(
                        stu -> stu.get("stuNo").toString()
                        , Collectors.toSet()
                )
        );
        System.out.println(set);
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

[123459, 123457, 123458, 123456]

需求二:求所有参加考试的学生的学号和姓名。

方案:

    
    public static void mapping2() {
        List> list = StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Set set = list.stream().collect(
                Collectors.mapping(
                        stu -> new HashMap() {
                            {
                                put("stuNo", stu.get("stuNo").toString());
                                put("stuName", stu.get("stuName").toString());
                            }
                        }
                        , Collectors.toSet()
                )
        );
        JSONArray arraySet = JSONArray.parseArray(JSON.toJSONString(set));
        System.out.println(arraySet);
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

[
    {
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

需求三:把相同班级的学生分数记录统计在一起,只返回学号和姓名。

方案:

    
    public static void group2() {
        List> list = StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Map>> map = list.stream().collect(
                Collectors.groupingBy(
                        g -> g.get("classNo").toString(),
                        Collectors.mapping(stu ->
                                        new HashMap() {
                                            {
                                                put("stuNo", stu.get("stuNo").toString());
                                                put("stuName", stu.get("stuName").toString());
                                            }
                                        },
                                Collectors.toSet()
                        )
                )
        );
        JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
        System.out.println(json);
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

{
    "123": [
        {
            "stuName": "张三", 
            "stuNo": "123456"
        }, 
        {
            "stuName": "李四", 
            "stuNo": "123457"
        }
    ], 
    "124": [
        {
            "stuName": "王五", 
            "stuNo": "123458"
        }, 
        {
            "stuName": "赵六", 
            "stuNo": "123459"
        }
    ]
}

maxBy/minBy

作用:求最大/最小记录。这里只演示maxBy方法,minBy方法大家以此类推。

需求一:求分数最高的一条记录。

方案:

    
    public static void maxBy() {
        List> list = StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Optional> optional = list.stream().collect(
                Collectors.maxBy(
                        (stu, stu2) -> {
                            BigDecimal sub = new BigDecimal(stu.get("grade").toString()).subtract(new BigDecimal(stu2.get("grade").toString()));
                            int compare = sub.compareTo(BigDecimal.ZERO);
                            return compare;
                        }
                )
        );
        if(optional.isPresent()){
            Map map = optional.get();
            JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
            System.out.println(json);
        }
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

{
    "courseName": "语文", 
    "courseNo": "Chinese", 
    "grade": 100, 
    "classNo": "123", 
    "className": "123班", 
    "stuName": "李四", 
    "stuNo": "123457"
}

partitioningBy

作用:按照指定的规则对数据进行分组。

需求一:将集合中大于10的数分为一组,将小于或等于10的数分为一组。

方案:

    
    public static void partitioning(){
        List list=StreamData.numList;
        System.out.println(list);
        Map> map = list.stream().collect(
                Collectors.partitioningBy(num -> num > 10)
        );
        JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
        System.out.println(json);
    }

原始数据:

[1, 2, 3, 6, 22, 8, 3, 0, 48]

返回结果:

{
    "false": [
        1, 
        2, 
        3, 
        6, 
        8, 
        3, 
        0
    ], 
    "true": [
        22, 
        48
    ]
}

需求二:将学生大于或等于18岁的分为一组,反之放到另一组。

方案:

    
    public static void partitioning2(){
        List list=StreamData.studentInfoList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        Map> map = list.stream().collect(
                Collectors.partitioningBy(student -> student != null && student.getAge() >= 18)
        );
        JSONObject json = JSONObject.parseObject(JSON.toJSONString(map));
        System.out.println(json);
    }

原始数据:

[
    {
        "sex": true, 
        "name": "张三", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "李四", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 13
    }, 
    {
        "sex": false, 
        "name": "王五", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "赵六", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 14
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 19
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }
]

返回结果:

{
    "false": [
        {
            "sex": true, 
            "name": "张三", 
            "chineseScore": 0, 
            "mathScore": 0, 
            "age": 12
        }, 
        {
            "sex": true, 
            "name": "李四", 
            "chineseScore": 0, 
            "mathScore": 0, 
            "age": 13
        }, 
        {
            "sex": false, 
            "name": "王五", 
            "chineseScore": 0, 
            "mathScore": 0, 
            "age": 12
        }, 
        {
            "sex": true, 
            "name": "赵六", 
            "chineseScore": 0, 
            "mathScore": 0, 
            "age": 14
        }, 
        {
            "sex": false, 
            "name": "钱七", 
            "chineseScore": 0, 
            "mathScore": 0, 
            "age": 12
        }, 
        {
            "sex": false, 
            "name": "钱七", 
            "chineseScore": 0, 
            "mathScore": 0, 
            "age": 16
        }, 
        {
            "sex": false, 
            "name": "钱七", 
            "chineseScore": 0, 
            "mathScore": 0, 
            "age": 16
        }, 
        {
            "sex": false, 
            "chineseScore": 0, 
            "mathScore": 0, 
            "age": 16
        }, 
        {
            "sex": false, 
            "chineseScore": 0, 
            "mathScore": 0, 
            "age": 16
        }
    ], 
    "true": [
        {
            "sex": false, 
            "name": "", 
            "chineseScore": 0, 
            "mathScore": 0, 
            "age": 19
        }
    ]
}

summarizing

作用:求流聚合后的数据。

需求一:求集合中的最大数,最小数,平均数,和,集合中元素的数量。

方案:

    
    public static void summarizing() {
        List list = StreamData.numList;
        System.out.println("原始数据:"+list);
        IntSummaryStatistics collect = list.stream().collect(
                Collectors.summarizingInt(a -> a)
        );
        System.out.println("平均数=" + collect.getAverage());
        System.out.println("元素数量=" + collect.getCount());
        System.out.println("和=" + collect.getSum());
        System.out.println("最大数=" + collect.getMax());
        System.out.println("最小数=" + collect.getMin());
    }

返回结果:

原始数据:[1, 2, 3, 6, 22, 8, 3, 0, 48]
平均数=10.333333333333334
元素数量=9
和=93
最大数=48
最小数=0

需求二:求学生的最高年龄,最低年龄,平均年龄,年龄总和,学生数量。

方案:

    
    public static void summarizing2() {
        List list = StreamData.studentInfoList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        IntSummaryStatistics collect = list.stream().collect(
                Collectors.summarizingInt(stu -> stu.getAge()
                )
        );
        System.out.println("平均年龄=" + collect.getAverage());
        System.out.println("学生数量=" + collect.getCount());
        System.out.println("年龄总和=" + collect.getSum());
        System.out.println("最高年龄=" + collect.getMax());
        System.out.println("最低年龄=" + collect.getMin());
    }

原始数据:

[
    {
        "sex": true, 
        "name": "张三", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "李四", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 13
    }, 
    {
        "sex": false, 
        "name": "王五", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": true, 
        "name": "赵六", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 14
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 12
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "钱七", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }, 
    {
        "sex": false, 
        "name": "", 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 19
    }, 
    {
        "sex": false, 
        "chineseScore": 0, 
        "mathScore": 0, 
        "age": 16
    }
]

返回结果:

平均年龄=14.6
学生数量=10
年龄总和=146
最高年龄=19
最低年龄=12

需求三:在学生的语文成绩大于98分的区间内,查询最高分,最低分,平均分,分数总和,符合条件分数的记录数。

方案:

    
    public static void summarizing3() {
        List> list = StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        DoubleSummaryStatistics collect = list.stream().filter(
                stu -> "Chinese".equals(stu.get("courseNo").toString()) && Double.parseDouble(stu.get("grade").toString()) > 98
        ).collect(
                Collectors.summarizingDouble(
                        stu -> Double.parseDouble(stu.get("grade").toString())
                )
        );
        System.out.println("平均分数=" + collect.getAverage());
        System.out.println("符合条件的数量=" + collect.getCount());
        System.out.println("分数总和=" + collect.getSum());
        System.out.println("最高分数=" + collect.getMax());
        System.out.println("最低分数=" + collect.getMin());
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

平均分数=99.46666666666665
符合条件的数量=3
分数总和=298.4
最高分数=100.0
最低分数=98.9

需求四:在学生的语文成绩大于98分的区间内,查询英语的最高分,英语的最低分,英语的平均分,英语的分数总和,符合条件分数的记录数。

方案:

    
    public static void summarizing4() {
        List> list = StreamData.studentAchievementList;
        JSONArray array = JSONArray.parseArray(JSON.toJSONString(list));
        System.out.println(array);
        //先求出符合条件的学生。
        Set set = list.stream().filter(
                stu -> "Chinese".equals(stu.get("courseNo").toString()) && Double.parseDouble(stu.get("grade").toString()) > 98
        ).map(
                stu -> stu.get("stuNo").toString()
        ).collect(
                Collectors.toSet()
        );
        //根据学号求结果
        DoubleSummaryStatistics collect = list.stream().filter(
                stu -> "English".equals(stu.get("courseNo").toString())&&set.contains(stu.get("stuNo").toString())
        ).collect(
                Collectors.summarizingDouble(
                        stu -> Double.parseDouble(stu.get("grade").toString())
                )
        );
        System.out.println("平均分数=" + collect.getAverage());
        System.out.println("符合条件的数量=" + collect.getCount());
        System.out.println("分数总和=" + collect.getSum());
        System.out.println("最高分数=" + collect.getMax());
        System.out.println("最低分数=" + collect.getMin());
    }

原始数据:

[
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 98.9, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 91.1, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 92, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "张三", 
        "stuNo": "123456"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 100, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 98.5, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 89, 
        "classNo": "123", 
        "className": "123班", 
        "stuName": "李四", 
        "stuNo": "123457"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 88.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 90, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 95, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "王五", 
        "stuNo": "123458"
    }, 
    {
        "courseName": "语文", 
        "courseNo": "Chinese", 
        "grade": 99.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "数学", 
        "courseNo": "Math", 
        "grade": 81.5, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }, 
    {
        "courseName": "英语", 
        "courseNo": "English", 
        "grade": 80, 
        "classNo": "124", 
        "className": "124班", 
        "stuName": "赵六", 
        "stuNo": "123459"
    }
]

返回结果:

平均分数=87.0
符合条件的数量=3
分数总和=261.0
最高分数=92.0
最低分数=80.0

项目下载地址

熟练使用stream操作集合,能通过例题举一反三,合理地将案例融入到实际工作中。

转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号