AVA8新特性之stream流各种用法（最大、最小、平均值、分组、求和、遍历、过滤、排序）

最新推荐文章于 2024-07-27 17:56:15 发布

扫地僧程序员

最新推荐文章于 2024-07-27 17:56:15 发布

阅读量1.6k

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_44707998/article/details/126592023

版权

构建一个User实体类供演示

/**
 * @author ligao
 * @Description:
 * @data 2022 年 08 月 28 日 17:55
 */
public class Users {

    /**
     * ID
     */
    private Long id;
    /**
     * 用户名
     */
    private String name;
    /**
     * 年龄
     */
    private int age;
    /**
     * 工号
     */
    private String jobNumber;
    /**
     * 性别
     */
    private String sex;
    /**
     * 注册时间
     */
    private Date entryDate;
    /**
     * 成员组织
     */
    private BigDecimal familyMemberQuantity;

    private Long userId;

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getJobNumber() {
        return jobNumber;
    }

    public void setJobNumber(String jobNumber) {
        this.jobNumber = jobNumber;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getEntryDate() {
        return entryDate;
    }

    public void setEntryDate(Date entryDate) {
        this.entryDate = entryDate;
    }

    public BigDecimal getFamilyMemberQuantity() {
        return familyMemberQuantity;
    }

    public void setFamilyMemberQuantity(BigDecimal familyMemberQuantity) {
        this.familyMemberQuantity = familyMemberQuantity;
    }

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    @Override
    public String toString() {
        return "Users{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", jobNumber='" + jobNumber + '\'' +
                ", sex='" + sex + '\'' +
                ", entryDate=" + DateFormatUtils.format(entryDate, "yyyy-MM-dd HH:mm:ss") +
                ", familyMemberQuantity=" + familyMemberQuantity +
                '}';
    }
}

一、根据字段分组得到多个List集合

/**
 * @author ligao
 * @Description:
 * @data 2022 年 08 月 28 日 17:55
 */

构建一个产生Users的静态法
/**
     * 生产虚拟用户
     *
     * @return
     */
    public static List<Users> produceUser() {
        List<Users> usersList = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            Users users = new Users();
            users.setId(Long.valueOf(i));
            users.setName("kobe" + i);
            users.setAge(15 + new Random().nextInt(5));
            users.setJobNumber("jobNumber" + i);
            if (i % 2 == 0) {
                users.setSex("男");
            } else {
                users.setSex("女");
            }
            users.setEntryDate(new Date());
            users.setFamilyMemberQuantity(new BigDecimal(i));
            usersList.add(users);
        }
        return usersList;
    }

二、集合求和

2.1 根据对象中的某个字段求和

/**
     * 根据年龄字段求总和
     */
    @Test
    public void getSumByStream() {
        List<Users> list = produceUser();
        int sum = list.stream().mapToInt(Users::getAge).sum();
        System.out.println("共计:" + list.size() + "个用户,所有年龄总和为:" + sum);
        // 求最大年龄
        Integer integer = list.stream().map(Users::getAge).max(Integer::compareTo).get();
        System.out.println(integer);
        // 得到最大年龄对象
        Users users = list.stream().max(Comparator.comparingInt(Users::getAge)).get();
        System.out.println(users);
        // 求平均年龄
        System.out.println(list.stream().mapToInt(Users::getAge).average().getAsDouble());
        // 求最大年龄
        System.out.println(list.stream().mapToInt(Users::getAge).max().getAsInt());
    }

2.2 List<数值型> 求和

/**
     * 根据List求和
     */
    @Test
    public void getListSumByJava8() {
        List<Integer> listInt = new ArrayList();
        List<Double> listDoub = new ArrayList();
        for (int i = 0; i < 500; i++) {
            listInt.add(new Random().nextInt(1000));
            listDoub.add(new Random().nextDouble());
        }
        System.out.println("=======数值型Integer求和======");
        Integer integer = listInt.stream().reduce(Integer::sum).orElse(0);
        System.out.println(integer);
        System.out.println("=======数值型Double求和======");
        Double integer1 = listDoub.stream().reduce(Double::sum).orElse(0.00);
        System.out.println(integer1);
        // 取最大值
        System.out.println(listInt.stream().reduce(Integer::max).orElse(0));
        System.out.println(listInt.stream().mapToInt(Integer::valueOf).max().getAsInt());
        // 取最小值
        System.out.println(listInt.stream().reduce(Integer::min).orElse(0));
        // 取平均值
        System.out.println(listInt.stream().mapToInt(Integer::valueOf).average().getAsDouble());
    }

三、遍历List集合

/**
     * 遍历对象
     */
    @Test
    public void traverseByJava8(){
        List<Users> list = produceUser();
        list.forEach(System.out::println);
    }

四、过滤List集合

/**
     * 过滤对象
     */
    @Test
    public void filterByJava8() {
        List<Users> list = produceUser();
        System.out.println("原始数据为:");
        System.out.println("==============过滤后的数据为===============");
        list.forEach(System.out::println);
        //筛选出年龄大于3岁小于8岁的对象
        List<Users> collect = list.stream().filter(s -> s.getAge() > 13 && s.getAge() < 18).collect(Collectors.toList());
        System.out.println("过滤结束后的数据为:");
        collect.forEach(System.out::println);
    }

五、获取List中的最大最小值

5.1 根据特定需求中的某个字段求最大最小

/**
     * 求最大最小值,根据业务类型选择合适的类型值
     */
    @Test
    public void maxOrMinByJava8() {
        List<Users> list = produceUser();
        //根据mapTO**得到最大最小  ---写法一
        double asDouble = list.stream().mapToDouble(Users::getAge).max().getAsDouble();
        System.out.println("将最大值转换为Double类型进行展示,最大为:" + asDouble);
        double asDouble1 = list.stream().mapToDouble(Users::getAge).min().getAsDouble();
        System.out.println("将最小值转换为Double类型进行展示,最小为:" + asDouble1);
        int asInt = list.stream().mapToInt(Users::getAge).max().getAsInt();
        System.out.println("将最大值转换为Int类型进行展示,最大为:" + asInt);
        //根据map得到最大最小  ---写法二(推荐)
        Integer integer = list.stream().map(Users::getAge).max(Integer::compareTo).get();
        System.out.println("将最大值转换为字段对应类型进行展示,最大为:" + integer);
        Integer integer1 = list.stream().map(Users::getAge).min(Integer::compareTo).get();
        System.out.println("将最小值转换为字段对应类型进行展示,最小为:" + integer1);
    }

5.2 根据特定需求中的某个字段求平均值

/**
     * 求最大最小值,根据业务类型选择合适的类型值
     */
    @Test
    public void avgByJava8() {
        List<Users> list = produceUser();
        double avgAge = list.stream().mapToDouble(Users::getAge).average().getAsDouble();
        System.out.println("平均年龄为:" + avgAge);
    }

六、根据需求将List转为Map

/**
     * List -> Map
     * 需要注意的是：
     * toMap 如果集合对象有重复的key，会报错Duplicate key ....
     * user1,user2的id都为1。
     * 可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
     */
    @Test
    public void mapToListByJava8() {
        List<Users> list = produceUser();
        Map<Long, Users> map = list.stream().collect(Collectors.toMap(Users::getId, a -> a, (k1, k2) -> k1));
        for (Map.Entry<Long, Users> entry : map.entrySet()) {
            Long key = entry.getKey();
            System.out.println("map中的key是:" + key);
            System.out.println("map中的value是:" + entry.getValue().toString());
        }

        // 根据ID和年龄获得map
        Map<Long, Integer> collect = list.stream().collect(Collectors.toMap(Users::getId, item -> Optional.ofNullable(item.getAge()).orElse(0)
                , (k1, k2) -> k1));
        System.out.println(collect.toString());
    }

七、List排序

/**
     * 排序(单字段/多字段排序)
     */
    @Test
    public void sortByJava8() {
        List<Users> list = produceUser();
        System.out.println("============未排序的数据=============");
        System.out.println(list.toString());
        try {
            //单字段排序，根据名字排序
            System.out.println("============单字段排序，根据名字排序=============");
            list.sort(Comparator.comparing(Users::getName));
            System.out.println(list.toString());
            //多字段排序,根据年龄再根据-->名字排序
            System.out.println("============多字段排序,根据年龄再根据-->名字排序=============");
            list.sort(Comparator.comparing(Users::getAge, (o1, o2) -> o2 - o1).thenComparing(Users::getName));
            System.out.println(list.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

八、List去重

/**
     * 去重
     */
    @Test
    public void distinctByJava8() {
        List<String> numList = new ArrayList();
        numList.add("kevin");
        numList.add("kevin");
        numList.add("kevin1");
        numList.add("kevin2");
        numList.add("kevin1");
        numList.add("kevin2");
        System.out.println("===========未去重的数据============");
        System.out.println(numList.toString());
        System.out.println("===========去重后的数据============");
        List<String> collect = numList.stream().distinct().collect(Collectors.toList());
        System.out.println(collect.toString());
    }

九、List的合并

9.1 List的合并之—>并集

/**
     * 得到两个集合的并集
     */
    @Test
    public void listByJava8() {
        List<String> list1 = new ArrayList();
        list1.add("aaa");
        list1.add("bbb");
        list1.add("ccc");
        list1.add("aaa1");
        List<String> list2 = list1;
        list2.add("ddd");
        list2.add("aaa");
        list2.add("eee");
        list2.add("ccc");
        list2.add("fff");
        list2.add("aaa1");
        list2.add("aaa2");

        //根据整个对象是否一致来去重合并得到并集
        System.out.println("==========并集: 集合A{1, 2, 3} 和集合B {2, 3, 4} 的并集是 {1, 2, 3, 4}==========");
        System.out.println("---->并集写法一 [去重]");
        System.out.println("============并集举例一:根据List去重特性合并多个Lits============");
        List<String> collect = Stream.of(list1, list2).flatMap(Collection::stream).distinct().collect(Collectors.toList());
        System.out.println(collect.toString());
        System.out.println("---->并集写法二 ");
        System.out.println("============并集举例二:根据List得到并集============");
        List<String> collect1 = list1.stream().filter(s -> list2.contains(s)).distinct().collect(Collectors.toList());
        System.out.println(collect1);
        System.out.println("==========交集: 集合A {1,2,3} 和集合B {2,3,4} 的交集为 {2,3}。即{1,2,3}∩{2,3,4}={2,3}==========");
    }

9.2 List的合并之—>交集(即两个或多个list重复的元素的集合)

/**
     * 得到两个集合的交集
     */
    @Test
    public void listBingByJava8() {
        System.out.println("==========交集: 集合A {1,2,3} 和集合B {2,3,4} 的交集为 {2,3}。即{1,2,3}∩{2,3,4}={2,3}==========");
        List<String> list1 = new ArrayList();
        list1.add("aaa");
        list1.add("bbb");
        list1.add("ccc");
        list1.add("aaa1");
        List<String> list2 = list1;
        list2.add("ddd");
        list2.add("aaa");
        list2.add("eee");
        list2.add("ccc");
        list2.add("fff");
        list2.add("aaa1");
        list2.add("aaa2");
        //合并List
        List<String> collect = list1.stream().filter(s -> list2.contains(s)).collect(Collectors.toList());
        System.out.println("============多个List合并后的元数据===========");
        System.out.println(collect);
        // 获得元素出现频率的 Map，键为元素，值为元素出现的次数
        List<String> collect1 = collect.stream().collect(Collectors.toMap(a -> a, a -> 1, (a, b) -> a + b))
                //  Set<Entry>转换为Stream<Entry>
                .entrySet().stream()
                // 过滤出元素出现次数大于 1 的 entry
                .filter(entry -> entry.getValue() > 1)
                // 获得 entry 的键（重复元素）对应的 Stream
                .map(entry -> entry.getKey())
                // 转化为 List并去重
                .distinct().collect(Collectors.toList());
        System.out.println("========合并后得到处理得到重复的数据========");
        System.out.println(collect1);
    }