stream流对集合进行排序，取集合的topN（sorted升序降序用法）

布满荆棘的人生 2023-10-09 21:40 52阅读 0赞

package com.tangbb.test1;
    
    import java.util.ArrayList;
    import java.util.Comparator;
    import java.util.List;
    import java.util.stream.Collectors;
    
    public class MapSort2 {
    
        public static void main(String[] args) {
            System.out.println("=======对象类型排序=======");
            List<Student> students = new ArrayList<>();
            Student student = new Student();
            student.setName("zhangsan");
            student.setAge(23);
            students.add(student);
            student = new Student();
            student.setName("lisi");
            student.setAge(34);
            students.add(student);
            student = new Student();
            student.setName("wangwu");
            student.setAge(25);
            students.add(student);
            System.out.println("=======最大值=======");
            // 求最大值
            Integer maxAge = students.stream().max(Comparator.comparing(Student::getAge)).get().getAge();
            System.out.println(maxAge);
            System.out.println("=======从大到小=======");
            // 根据age进行排序 使用reversed() 实现从大到小排列
            List<Student> studentsDesc = students.stream().sorted(Comparator.comparing(Student::getAge).reversed()).collect(Collectors.toList());
            System.out.println(studentsDesc);
            System.out.println("=======从小到大 top 10=======");
            // 根据age进行排序 使用sorted() 默认从小到大即升序排列，取top 10
            List<Student> studentsAsc = students.stream().sorted(Comparator.comparing(Student::getAge)).limit(10).collect(Collectors.toList());
            System.out.println(studentsAsc);
    
            System.out.println("=======数值类型排序=======");
            List<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(5);
            list.add(3);
            list.add(4);
            List<Integer> collect = list.stream().sorted(Comparator.comparing(Integer::intValue).reversed()).collect(Collectors.toList());
            System.out.println(collect.toString());
        }
    
    
    }
    
    class Student {
        private String name;
        private Integer age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

List<类> list; 代表某集合
     
    //返回 对象集合以类属性一升序排序
    list.stream().sorted(Comparator.comparing(类::属性一));
     
    //返回 对象集合以类属性一降序排序 注意两种写法
    //先以属性一升序,结果进行属性一降序
    list.stream().sorted(Comparator.comparing(类::属性一).reversed());
     //以属性一降序
    list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));
     
    //返回 对象集合以类属性一升序 属性二升序
    list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));
     
    //返回 对象集合以类属性一降序 属性二升序 注意两种写法
     //先以属性一升序,升序结果进行属性一降序,再进行属性二升序
    list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));
     //先以属性一降序,再进行属性二升序
    list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));
     
    //返回 对象集合以类属性一降序 属性二降序 注意两种写法
    //先以属性一升序,升序结果进行属性一降序,再进行属性二降序
    list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));
    //先以属性一降序,再进行属性二降序
    list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));
     
    //返回 对象集合以类属性一升序 属性二降序 注意两种写法
     //先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
    list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed()); 
    //先以属性一升序,再进行属性二降序 
    list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));