• Java List排序 java ListMap 排序 Java listmap 模拟 oracle 排序 Java listmap 模拟 mysql 排序

            Java List排序 java ListMap 排序 Java listmap 模拟 oracle 排序 Java listmap 模拟 mysql 排序

    一、概述

            近期的开发工作中，遇到一个需求： 对 Listmap的结果集进行排序，类似于模拟 数据库中的Order By 排序。那么主要的需求有： 排序方式 ASC/DESC ; null 值处理：NULL FIRST / NULL LAST 。 在Java 中要实现以上相应的功能，对List进行排序，会遇到对应问题： 元素中有 null ，排序时候会抛出 NPE 、 null 元素放在 最前、最后面的问题。

            本文将基于Java8，逐一演示，上述中出现问题的对应示例代码；最终给出 List 排序的解决方案，实现易用性，通用性。

    二、问题

            1、元素有null，排序处理：

    1. /**
    2.      * Description: null 值处理
    3.      * 
       1. null 元素，排序 NPE
    4.      * 
       2. 解决： null 放在最前面、最后面
    5.      * @param
    6.      * @return void
    7.      * @version v1.0
    8.      * @author wu
    9.      * @date 2022/10/17 15:43
    10.      */
    11.     @Test
    12.     public void nullListTest(){
    13.         ArrayList list = Lists.newArrayList("22","33",null,"11");
    14.          System.out.println("nullListTest  排序前:" + list);
    15.         // list中有 null 元素，排序会抛出 NPE
    16.         list.sort(Comparator.comparing(e->e)); // 抛出 NPE
    17.         list.sort((e1,e2)->e1.compareTo(e2)); // 抛出 NPE
    18. //        list.sort(Comparator.comparing(String::valueOf)); // 避免npe
    19.  
    20.         // null 值处理： null 放在最前
    21.         list.sort(Comparator.comparing(e->e,Comparator.nullsFirst(String::compareTo)));
    22.         System.out.println("nullListTest  排序后: null 放在最前:" + list);
    23.  
    24.         // null 值处理： null 放在最后
    25.         list.sort(Comparator.comparing(e->e,Comparator.nullsLast(String::compareTo)));
    26.         System.out.println("nullListTest  排序后:null 放在最后:" + list);
    27.     }

            1.1、输出结果：

    1. nullListTest  排序前:[22, 33, null, 11]
    2.  
    3. java.lang.NullPointerException 
    4. ...

            2、倒序 DESC时，null 值放在 最前面、最后面的处理

    1. /**
    2.      * Description: 倒序的时候， null 值处理
    3.      * 
       1. null 最前面： nullsLast 方法
    4.      * 
       2. null 最后面： nullsFirst 方法
    5.      * @return void
    6.      * @version v1.0
    7.      * @author wu
    8.      * @date 2022/10/17 16:37
    9.      */
    10.     @Test
    11.     public void nullDESCTest() throws Exception{
    12.         ArrayList list = Lists.newArrayList("22","33",null,"11");
    13.         System.out.println("nullDESCTest  排序前:" + list);
    14.  
    15.         // DESC ,  null  first
    16. //        list.sort(Comparator.comparing((String e)->e,Comparator.nullsFirst(String::compareTo)).reversed());
    17.         list.sort(Comparator.comparing((String e)->e,Comparator.nullsLast(String::compareTo)).reversed());
    18.         System.out.println("nullDESCTest  DESC ,  null  first :" + list);
    19.  
    20.         // DESC ,  null  last
    21.         list.sort(Comparator.comparing((String e)->e,Comparator.nullsFirst(String::compareTo)).reversed());
    22.         System.out.println("nullDESCTest  DESC ,  null  last :" + list);
    23.  
    24.     }

            2.1、输出结果：

    1. nullDESCTest  排序前:[22, 33, null, 11]
    2. nullDESCTest  DESC ,  null  first :[null, 33, 22, 11]
    3. nullDESCTest  DESC ,  null  last :[33, 22, 11, null]

            3、数字是字符串类型时，排序不对的问题：

    1.   /**
    2.      * Description: 字符串类型数字 排序
    3.      * 
       解决：字符串转换为数字，进行排序
    4.      * @return void
    5.      * @version v1.0
    6.      * @author wu
    7.      * @date 2022/10/17 15:44
    8.      */
    9.     @Test
    10.     public void strNumTest() throws Exception{
    11.         List list = Lists.newArrayList("10","11","101","111");
    12.         System.out.println("strNumTest  排序前:" + list);
    13.  
    14.         // 倒序排序
    15.         list.sort(Comparator.comparing(String::valueOf).reversed());
    16. //        list.sort(Comparator.comparing((String e)->Integer.valueOf(e)).reversed()); // 解决排序不对的问题
    17.         System.out.println("strNumTest  排序后:" + list);
    18.  
    19.     }

            3.1、输出结果是：

    1. strNumTest  排序前:[10, 11, 101, 111]
    2. strNumTest  排序后:[111, 11, 101, 10]

    三、解决 --- 通用排序方案

            1、上述代码中，演示了可能出现的问题，以及对应的解决方案：

    • 元素中有null ， 使用 Comparator.nullsFirst / Comparator.nullsLast
    • 倒序时null元素 处理： 最前面 --- Comparator.nullsLast ； 最后面 --- Comparator.nullsFirst
    • 数字是字符串类型时： 转换为数字进行排序

            2、List> 排序可能遇到问题：

    • 排序字段不确定
    • 排序字段类型不确定
    • 排序方式不确定
    • 可能 出现null元素

            3、经整理汇总后，通用排序流程如下：

            4、定义一个 ListMapConfig 配置类 ，统一维护相关的配置：

    1. /**
    2.  * Description: List Map 排序 配置
    3.  * @author w
    4.  * @version 1.0
    5.  * @date 2022/10/17 16:09
    6.  */
    7. public class ListMapConfig {
    8.  
    9.     private String orderProperty ; // 排序字段：
    10.     private String porpertyType = "STRING"; // 属性类型： STRING / NUMBER
    11.     private String orderMode ="ASC"; // 排序方式： ASC/DESC
    12.     private String orderModeNull ="LAST"; // null值处理： FIRST / LAST
    13.     
    14.     public static ListMapConfig getDefault(){
    15.         return new ListMapConfig();
    16.     }
    17.     // ignore getter / setter     
    18. }

            5、通用的 ListMap排序方法：

    1. public static void processSort(List> listMap , ListMapConfig config){
    2.     String orderProperty = config.getOrderProperty();
    3.     Assert.isTrue(StringUtils.isNotBlank(orderProperty));
    4.  
    5.     if("NUMBER".equals(config.getPorpertyType())){
    6.         // 数字 类型排序
    7.         if("DESC".equals(config.getOrderMode())){
    8.             if("FIRST".equals(config.getOrderModeNull())){
    9.                 listMap.sort(Comparator.comparing((Map e)->{
    10.                     Object val = e.get(orderProperty);
    11.                     return val == null ? null : Double.valueOf(val.toString());
    12.                     // 倒序时，null值放在最后，反过来：需要用 nullsLast
    13.                 },Comparator.nullsLast(Double::compareTo)).reversed());
    14.             }else {
    15.                 listMap.sort(Comparator.comparing((Map e)->{
    16.                     Object val = e.get(orderProperty);
    17.                     return val == null ? null : Double.valueOf(val.toString());
    18.                     // 倒序时，null值放在最后，反过来：需要用 nullsFirst
    19.                 },Comparator.nullsFirst(Double::compareTo)).reversed());
    20.             }
    21.         }else {
    22.             if("FIRST".equals(config.getOrderModeNull())){
    23.                 listMap.sort(Comparator.comparing((Map e)->{
    24.                     Object val = e.get(orderProperty);
    25.                     return val == null ? null : Double.valueOf(val.toString());
    26.                 },Comparator.nullsFirst(Double::compareTo)));
    27.             }else {
    28.                 listMap.sort(Comparator.comparing((Map e)->{
    29.                     Object val = e.get(orderProperty);
    30.                     return val == null ? null : Double.valueOf(val.toString());
    31.                 },Comparator.nullsFirst(Double::compareTo)));
    32.             }
    33.         }
    34.     }else if("STRING".equals(config.getPorpertyType())){
    35.         // 字符串 类型排序
    36.         if("DESC".equals(config.getOrderMode())){
    37.             if("FIRST".equals(config.getOrderModeNull())){
    38.                 listMap.sort(Comparator.comparing((Map e) -> {
    39.                     Object val =  e.get(orderProperty);
    40.                     return null == val ? null : val.toString();
    41.                     // 倒序时，null值放在最后，反过来：需要用 nullsLast
    42.                 },Comparator.nullsLast(String::compareTo)).reversed());
    43.             }else {
    44.                 listMap.sort(Comparator.comparing((Map e) -> {
    45.                     Object val =  e.get(orderProperty);
    46.                     return null == val ? null : val.toString();
    47.                     // 倒序时，null值放在最后，反过来：需要用 nullsFirst
    48.                 },Comparator.nullsFirst(String::compareTo)).reversed());
    49.             }
    50.         }else {
    51.             if("FIRST".equals(config.getOrderModeNull())){
    52.                 listMap.sort(Comparator.comparing((Map e) -> {
    53.                     Object val =  e.get(orderProperty);
    54.                     return null == val ? null : val.toString();
    55.                 },Comparator.nullsFirst(String::compareTo)));
    56.             }else {
    57.                 listMap.sort(Comparator.comparing((Map e) -> {
    58.                     Object val =  e.get(orderProperty);
    59.                     return null == val ? null : val.toString();
    60.                 },Comparator.nullsLast(String::compareTo)));
    61.             }
    62.         }
    63.     }
    64. }

    四、代码测试

            1、创建一个 ListMapSortTest2 测试类：

    1. public class ListMapSortTest2 {
    2.  
    3.   static   List orderList =  null;
    4.   static  List> listMap = null;
    5.  
    6.     public static void main(String[] args) {
    7.         init();
    8.         System.out.println(orderList);
    9.  
    10.         // 1、转换为map
    11.         listMap = com.google.common.collect.Lists.newArrayList();
    12.         for (Order e : orderList) {
    13.             JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(e));
    14.             Map map = JSON.toJavaObject(jsonObject, Map.class);
    15.             listMap.add(map);
    16.         }
    17.         System.out.println("listMap :"+listMap);
    18.  
    19.         ListMapConfig config = ListMapConfig.getDefault();
    20.         config.setOrderProperty("appNo");
    21.  
    22.         // STRING-TEST1: ASC - NULL FIRST
    23.         config.setOrderModeNull("FIRST");
    24.         processSort(listMap,config);
    25.         System.out.println("STRING-TEST1: ASC - NULL FIRST : " + listMap);
    26.  
    27.         // STRING-TEST2: ASC - NULL LAST
    28.         config.setOrderModeNull("LAST");
    29.         processSort(listMap,config);
    30.         System.out.println("STRING-TEST2: ASC - NULL LAST : " + listMap);
    31.  
    32.         // STRING-TEST3: DESC - NULL FIRST
    33.         config.setOrderModeNull("FIRST");
    34.         config.setOrderMode("DESC");
    35.         processSort(listMap,config);
    36.         System.out.println("STRING-TEST3: DESC - NULL FIRST : " + listMap);
    37.  
    38.         // STRING-TEST4: DESC - NULL LAST
    39.         config.setOrderModeNull("LAST");
    40.         config.setOrderMode("DESC");
    41.         processSort(listMap,config);
    42.         System.out.println("STRING-TEST4: DESC - NULL LAST : " + listMap);
    43.  
    44.     }
    45.  
    46.     private static void init() {
    47.         orderList = Lists.newArrayList();
    48.         orderList.add(new Order(1,"小明","203"));
    49.         orderList.add(new Order(2,"小红",null));
    50.         orderList.add(new Order(3,"小刚","404"));
    51.     }
    52.     
    53.     static class Order {
    54.         private Integer id;
    55.         private String name;
    56.         private String appNo;
    57.  
    58.         public Order(Integer id, String name, String appNo) {
    59.             this.id = id;
    60.             this.name = name;
    61.             this.appNo = appNo;
    62.         }
    63.     
    64.         public Order() {
    65.         }
    66.     
    67.         public Integer getId() {
    68.             return id;
    69.         }
    70.     
    71.         public void setId(Integer id) {
    72.             this.id = id;
    73.         }
    74.     
    75.         public String getName() {
    76.             return name;
    77.         }
    78.     
    79.         public void setName(String name) {
    80.             this.name = name;
    81.         }
    82.     
    83.         public String getAppNo() {
    84.             return appNo;
    85.         }
    86.     
    87.         public void setAppNo(String appNo) {
    88.             this.appNo = appNo;
    89.         }
    90.     
    91.         @Override
    92.         public String toString() {
    93.             return "Order{" +
    94.                     "id=" + id +
    95.                     ", name='" + name + '\'' +
    96.                     ", appNo='" + appNo + '\'' +
    97.                     '}';
    98.         }
    99.     }
    100. }

            3、注意：Number类型，未测试！

    五、总结

            1、本文初步解决 List 集合的排序问题，因 map集合中元素类型的不确定性，所以 当前写了2种排序方式：统一按照字符串排序 或者 数字类型 ； 在 ListMapConfig.porpertyType 中，可以添加 相应的其他类型，进行功能扩展 。 比如： java.util.Date 类型处理。

            2、ListMapConfig 类中，porpertyType 等属性，可以定义为 枚举类型， 便于更好的理解，和后续扩展。

            3、通用排序方法：processSort ， 写了太多的 if else ， 可以引入设计模式，更加优雅！

    排序相关的文章资料参考：

     

    使用MySQL FIELD函数实现自定义排序 特定字段排序 指定字段排序_HaHa_Sir的博客-CSDN博客

    Java List集合排序 Java8 List集合排序方法 Java Lambda集合排序_HaHa_Sir的博客-CSDN博客_java8 集合排序 

    Oracle 中文排序 Oracle 中文字段排序_HaHa_Sir的博客-CSDN博客_oracle 中文排序

  • 相关阅读:
    Mybatis-plus 使用
    高速电路设计笔记----第二章
    2024 证券从业资格证考试备考资料分享
    速查！PMP考试成绩已出！
    嵌入式linux系统中面试过程经验分享
    docker 安装 neo4j
    [项目管理-6]：软硬件项目管理 - 项目沟通管理（渠道、方法）
    Java项目：SSM校园班级同学通讯录管理系统
    Flume环境搭建
    tf-vsn网络
  • 原文地址：https://blog.csdn.net/HaHa_Sir/article/details/127629841