1.集合内排序（2种方法）

方法一：
//从小到大：
list = list.sort((a, b) -> {
            Double d1 = a.getPQI();
            Double d2 = b.getPQI();
            return d1.compareTo(d2);
        });
        
//从大到小：
list = list.sort((a, b) -> {
            Double d1 = a.getPQI();
            Double d2 = b.getPQI();
            return d2.compareTo(d1);
        });

方法二：
list = list.stream().sorted(Comparator.comparing(p -> p.getPQI())).collect(Collectors.toList());

示例：

 @Test
    public void test(){

        UserInfo user1 = new UserInfo();
        user1.id = 1;
        user1.userName = "hoshi";
        user1.age = 27;
        UserInfo user2 = new UserInfo();
        user2.id = 2;
        user2.userName = "dk";
        user2.age = 26;
        UserInfo user3 = new UserInfo();
        user3.id = 3;
        user3.userName = "SEUNGKWAN";
        user3.age = 25;
        UserInfo user4 = new UserInfo();
        user4.id = 4;
        user4.userName = "dino";
        user4.age = 24;

        List<UserInfo> lst1 = Arrays.asList(user1, user3, user4, user2);
        
        Iterator<UserInfo> iterator = lst1.iterator();
        while(iterator.hasNext()){
            UserInfo next = iterator.next();
            System.out.println("id:"+next.id+", tname:"+next.userName+", tage:"+next.age);
        }

        System.out.println("n排序后：n");
        lst1 = lst1.stream().sorted(Comparator.comparing(p -> p.age)).collect(Collectors.toList());
        iterator = lst1.iterator();
        while(iterator.hasNext()){
            UserInfo next = iterator.next();
            System.out.println("id:"+next.id+", tname:"+next.userName+", tage:"+next.age);
        }
    }

运行结果如下：

2.集合与集合排序

现有实体如下：

@Data
public class RoadIndexResponse implements Serializable {

    @ApiModelProperty(value = "开始桩号（公里）")
    private Double beginMile;

    @ApiModelProperty(value = "结束桩号（公里）")
    private Double endMile;

    @ApiModelProperty(value = "当前年份")
    private Integer year;

    @ApiModelProperty(value = "PQI")
    private Double pqi;
}

现有一组数据如下：

List<List<RoadIndexResponse>> lstResult = 
[
	
    [
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2023,
        "pqi": 78.46428476603232
      },
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2023,
        "pqi": 78.53853723083152
      }
    ],
    [
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2022,
        "pqi": 82.96
      },
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2022,
        "pqi": 83.22
      }
    ],
    [
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2025,
        "pqi": 82.96
      },
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2025,
        "pqi": 83.22
      }
    ],[
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2024,
        "pqi": 74.96540901482958
      },
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2024,
        "pqi": 74.72799712436779
      }
    ]
] 

需求：按year顺序展示

代码如下：

lstResult.sort((a, b) -> {
            Integer d1 = a.get(0).getYear();
            Integer d2 = b.get(0).getYear();
            return d1.compareTo(d2);
        });

排序后的结果：

  [
    [
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2022,
        "pqi": 82.96
      },
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2022,
        "pqi": 83.22
      }
    ],
      [
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2023,
        "pqi": 78.46428476603232
      },
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2023,
        "pqi": 78.53853723083152
      }
    ],
    [
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2024,
        "pqi": 74.96540901482958
      },
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2024,
        "pqi": 74.72799712436779
      }
    ],
    [
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2025,
        "pqi": 82.96
      },
      {
        "beginMile": 6400,
        "endMile": 7000,
        "year": 2025,
        "pqi": 83.22
      }
    ]
] 

3.拓展

抄自https://blog.csdn.net/qq_40063053/article/details/117554325

//返回 对象集合以类属性一升序排序
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()));

最后

以上就是幸福金针菇最近收集整理的关于【java】集合排序，集合内排序，集合与集合排序，stream().sorted(Comparator.comparing(p -＞ p.age))，list.sort((a, b) -＞ {}；1.集合内排序（2种方法）2.集合与集合排序3.拓展的全部内容，更多相关【java】集合排序，集合内排序，集合与集合排序，stream().sorted(Comparator.comparing(p内容请搜索靠谱客的其他文章。