List中文排序&对象多属性排序

梦里梦外; 2023-06-22 03:26 4阅读 0赞

根据姓名首字母升序

## 引入maven依赖 ##

<dependency>
       <groupId>org.clojars.cbilson</groupId>
        <artifactId>pinyin4j</artifactId>
        <version>2.5.0</version>
    </dependency>

## 贴上代码 ##

private void orderByDoctorName(List<DoctorListResp> result) { 
       Collections.sort(result, (s1, s2) -> { 
            String o1 = s1.getDoctorName();
            String o2 = s2.getDoctorName();
            for (int i = 0; i < o1.length() && i < o2.length(); i++) { 
    
                int codePoint1 = o1.charAt(i);
                int codePoint2 = o2.charAt(i);
    
                if (Character.isSupplementaryCodePoint(codePoint1)
                        || Character.isSupplementaryCodePoint(codePoint2)) { 
                    i++;
                }
    
                if (codePoint1 != codePoint2) { 
                    if (Character.isSupplementaryCodePoint(codePoint1)
                            || Character.isSupplementaryCodePoint(codePoint2)) { 
                        return codePoint1 - codePoint2;
                    }
    
                    String pinyin1 = PinyinHelper.toHanyuPinyinStringArray((char) codePoint1) == null
                            ? null : PinyinHelper.toHanyuPinyinStringArray((char) codePoint1)[0];
                    String pinyin2 = PinyinHelper.toHanyuPinyinStringArray((char) codePoint2) == null
                            ? null : PinyinHelper.toHanyuPinyinStringArray((char) codePoint2)[0];
    
                    // 两个字符都是汉字
                    if (pinyin1 != null && pinyin2 != null) { 
                        if (!pinyin1.equals(pinyin2)) { 
                            return pinyin1.compareTo(pinyin2);
                        }
                    } else { 
                        return codePoint1 - codePoint2;
                    }
                }
            }
            return o1.length() - o2.length();
        });
    }

## POJO ##

//
    package com.pica.cloud.patient.health.common.dto.wechat;
    
    import io.swagger.annotations.ApiModel;
    import io.swagger.annotations.ApiModelProperty;
    import lombok.Data;
    
    import java.io.Serializable;
    
    /** * @ClassName DoctorListDto * @Description 我的医生列表响应对象 * @Author Chongwen.jiang * @Date 2019/1/9 17:45 * @ModifyDate 2019/1/9 17:45 * @Version 1.0 */
    @ApiModel("医生列表响应对象")
    @Data
    public class DoctorListResp implements Serializable{ 
    
        @ApiModelProperty("医生id")
        private Integer doctorId;
    
        @ApiModelProperty("医生姓名")
        private String doctorName;
    
        @ApiModelProperty("医院名称（exitedHospital=2时则表示之前的医院名称）")
        private String hospitalName;
    
        @ApiModelProperty("医生头像")
        private String headImageUrl;
    
        @ApiModelProperty("医院id")
        private Long hospitalId;
    
        @ApiModelProperty("退出机构标识 2：已退出原有机构，尚未加入新机构")
        private Integer exitedHospital;
    
    
    }

## java8对多个属性排序 ##

public static void main(String[] args) { 
       List<DoctorListResp> list = new ArrayList<>();
        DoctorListResp r = new DoctorListResp();
        r.setDoctorId(1);
        r.setHospitalId(Long.valueOf(1L));
    
        DoctorListResp r2 = new DoctorListResp();
        r2.setDoctorId(2);
        r2.setHospitalId(Long.valueOf(2L));
    
        DoctorListResp r3 = new DoctorListResp();
        r3.setDoctorId(2);
        r3.setHospitalId(Long.valueOf(1L));
    
        DoctorListResp r4 = new DoctorListResp();
        r4.setDoctorId(3);
        r4.setHospitalId(Long.valueOf(3L));
    
        DoctorListResp r5 = new DoctorListResp();
        r5.setDoctorId(3);
        r5.setHospitalId(Long.valueOf(4L));
    
        DoctorListResp r6 = new DoctorListResp();
        r6.setDoctorId(3);
        r6.setHospitalId(Long.valueOf(7L));
    
        list.add(r);
        list.add(r2);
        list.add(r3);
        list.add(r4);
        list.add(r5);
        list.add(r6);
    
        // 1、根据doctorId升序
        list = list.stream().sorted(
                        Comparator.comparing(DoctorListResp::getDoctorId))
                .collect(Collectors.toList());
    
        // 2、根据doctorId降序 注意两种写法：
        list = list.stream().sorted(
                        Comparator.comparing(DoctorListResp::getDoctorId).reversed())
                .collect(Collectors.toList());
        // 先以doctorId升序,结果进行doctorId降序
        list = list.stream().sorted(
                        Comparator.comparing(DoctorListResp::getDoctorId, Comparator.reverseOrder()))
                .collect(Collectors.toList());
    
        // 3、返回 对象集合以类doctorId升序 hospitalId升序
        list = list.stream().sorted(
                        Comparator.comparing(DoctorListResp::getDoctorId)
                        .thenComparing(DoctorListResp::getDoctorId))
                .collect(Collectors.toList());
    
        // 4、返回 对象集合以类属性一降序 属性二升序 注意两种写法：
        // 先以属性一升序,升序结果进行属性一降序,再进行属性二升序
        list = list.stream().sorted(
                        Comparator.comparing(DoctorListResp::getDoctorId).reversed()
                        .thenComparing(DoctorListResp::getHospitalId))
                .collect(Collectors.toList());
        // 先以属性一降序,再进行属性二升序
        list = list.stream().sorted(
                        Comparator.comparing(DoctorListResp::getDoctorId, Comparator.reverseOrder())
                        .thenComparing(DoctorListResp::getHospitalId))
                .collect(Collectors.toList());
    
        // 5、返回 对象集合以类属性一降序 属性二降序 注意两种写法：
        // 先以属性一升序,升序结果进行属性一降序,再进行属性二降序
        list = list.stream().sorted(
                        Comparator.comparing(DoctorListResp::getDoctorId).reversed()
                        .thenComparing(DoctorListResp::getHospitalId, Comparator.reverseOrder()))
                .collect(Collectors.toList());
        // 先以属性一降序,再进行属性二降序
        list = list.stream().sorted(
                        Comparator.comparing(DoctorListResp::getDoctorId,
                        Comparator.reverseOrder()).thenComparing(DoctorListResp::getHospitalId, Comparator.reverseOrder()))
                .collect(Collectors.toList());
    
        // 6、返回 对象集合以类属性一升序 属性二降序 注意两种写法：
        //先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
        list = list.stream().sorted(
                        Comparator.comparing(DoctorListResp::getDoctorId).reversed()
                        .thenComparing(DoctorListResp::getHospitalId).reversed())
                .collect(Collectors.toList());
        // 先以属性一升序,再进行属性二降序
        list = list.stream().sorted(
                        Comparator.comparing(DoctorListResp::getDoctorId)
                        .thenComparing(DoctorListResp::getHospitalId, Comparator.reverseOrder()))
                .collect(Collectors.toList());
    
    
        // 输出打印list集合
        System.out.println(JSON.toJSONString(list, true));
    
    
    }