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

Mr Tang

已于 2024-07-23 15:53:32 修改

阅读量3k

点赞数 2

CC 4.0 BY-SA版权

分类专栏： java 文章标签： java

于 2023-05-06 08:57:39 首次发布

本文链接：https://blog.csdn.net/qq_45443475/article/details/130519212

java 专栏收录该内容

53 篇文章

订阅专栏

该代码示例展示了如何使用Java8的StreamAPI对对象列表进行排序。通过Comparator比较器，实现了按对象属性（如年龄）的升序和降序排序，以及多个属性复合排序的场景。同时，也演示了对数值列表的排序操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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()));

//汉字首字母排序

import java.text.Collator;  
import java.util.*;  
  
class Item {  
    private String name;  
    private int count;  
  
    // 构造函数、getter和setter省略...  
  
    @Override  
    public String toString() {  
        return "Item{" +  
               "name='" + name + '\'' +  
               ", count=" + count +  
               '}';  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
        List<Item> items = new ArrayList<>();  
        items.add(new Item("苹果", 5));  
        items.add(new Item("香蕉", 10));  
        items.add(new Item("樱桃", 10));  
        items.add(new Item("枣子", 3));  
  
        // 使用Collator进行本地化不敏感的字符串比较  
        Collator collator = Collator.getInstance(Locale.CHINA);  
        collator.setStrength(Collator.PRIMARY); // 设置为按首字母排序  
  
        // 排序  
        items.sort(Comparator.comparingInt(Item::getCount).reversed()  
                      .thenComparing(item -> collator.getCollationKey(item.getName())));  
  
        // 打印排序后的List  
        for (Item item : items) {  
            System.out.println(item);  
        }  
    }  
}