【java】集合排序，集合内排序，集合与集合排序，stream().sorted(Comparator.comparing(p -＞ p.age))，list.sort((a, b) -＞ {}；

骑猪看日落 2024-03-27 14:18 53阅读 0赞

#### 目录 ####

*  1.集合内排序（2种方法）
 *  2.集合与集合排序
 *  3.拓展

## 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);
            }
        }

运行结果如下：  
![在这里插入图片描述][5aef9117aa2f42ba99c38de1f077a0dc.png_pic_center]

## 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][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()));

![在这里插入图片描述][ed61fe2198c74b749cc8cb2e870f27e4.jpeg_pic_center]

[5aef9117aa2f42ba99c38de1f077a0dc.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/06fd345faefd4584b8616478bd51ddb3.png
[https_blog.csdn.net_qq_40063053_article_details_117554325]: https://blog.csdn.net/qq_40063053/article/details/117554325
[ed61fe2198c74b749cc8cb2e870f27e4.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/17247a00f3a54961a4924f28a99f1605.png