前言

在开发当中我们往往会接到这样的需求，就是让我们对一个列表（List）的多个字段进行排序。这个时候，我们把这个方法抽取成一个工具类，因为这种操作往往是项目全局通用的。

案例演示

工具类

package com.starry.ops.utils;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Comparator;
import java.util.Date;
import java.util.List;

/**
 * 这是一个自定义排序的类，专门针对列表（List）中的数据进行排序；可按指定方法进行。
 * 目前实现对字符串（String）、日期（Date）、整型（Integer）等三种对象进行排序。
 *
 * @param <E>
 */
public class SortListUtil<E> {

    /**
     * 对列表中的数据按指定字段进行排序。要求类必须有相关的方法返回字符串、整型、日期等值以进行比较。
     *
     * @param list
     * @param method
     * @param reverseFlag
     */
    public void sortByMethod(List<E> list, final String method,
                             final boolean reverseFlag) {
        list.sort(new Comparator<Object>() {
            @Override
            @SuppressWarnings("unchecked")
            public int compare(Object arg1, Object arg2) {
                int result = 0;
                try {
                    Method m1 = ((E) arg1).getClass().getMethod(method, null);
                    Method m2 = ((E) arg2).getClass().getMethod(method, null);
                    Object obj1 = m1.invoke(((E) arg1), null);
                    Object obj2 = m2.invoke(((E) arg2), null);
                    if (obj1 instanceof String) {
                        // 字符串
                        result = obj1.toString().compareTo(obj2.toString());
                    } else if (obj1 instanceof Date) {
                        // 日期
                        long l = ((Date) obj1).getTime() - ((Date) obj2).getTime();
                        if (l > 0) {
                            result = 1;
                        } else if (l < 0) {
                            result = -1;
                        }
                    } else if (obj1 instanceof Integer) {
                        // 整型（Method的返回参数可以是int的，因为JDK1.5之后，Integer与int可以自动转换了）
                        result = (Integer) obj1 - (Integer) obj2;
                    } else {
                        // 目前尚不支持的对象，直接转换为String，然后比较，后果未知
                        result = obj1.toString().compareTo(obj2.toString());

                        System.err.println("MySortList.sortByMethod方法接受到不可识别的对象类型，转换为字符串后比较返回...");
                    }

                    if (reverseFlag) {
                        // 倒序
                        result = -result;
                    }
                } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
                    e.printStackTrace();
                }
                return result;
            }
        });
    }
}

实体类

比如这里我们需要对下面所有数量字段进行排序

@Data
@ApiModel
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SecurityGroupListVo {

    @ApiModelProperty("安全组Id(数据库中的Id)")
    private String securityGroupId;

    @ApiModelProperty("安全组名称")
    private String securityGroupName;

    @ApiModelProperty("vpc名称")
    private String vpcName;

    @ApiModelProperty("云服务器数量")
    private Integer cloudServerNum;

    @ApiModelProperty("裸金属服务器数量")
    private Integer bareMetalServerNum;

    @ApiModelProperty("GPU云服务器数量")
    private Integer computerGpuNum;

    @ApiModelProperty("GPU裸金属服务器数量")
    private Integer computerGpuBareMetalNum;

    @ApiModelProperty("专属宿主机服务器数量")
    private Integer exclusiveComputerNum;

    @ApiModelProperty("入站规则数量")
    private Integer inboundRulesNum;

    @ApiModelProperty("出站规则数量")
    private Integer outboundRulesNum;

    @ApiModelProperty("备注")
    private String remark;

}

实际操作

第一步：我们new出我们的工具类，然后这个<>泛型里面放的就是我们具体要返回给前端的哪个类，规范的话就是Vo、或则DTO
sortByMethod方法参数：
- 参数一：具体的返回List
- 参数二：要做排序的字段，这里不管你用的是原始方法，还是Lombok都是可以这样去get的
- 第三个参数：默认：true）
下面我就写了一个思路提供，具体可以根据需求结合变动。

List<SecurityGroupListVo> securityGroupVoList = new ArrayList<>();
 SecurityGroupListVo securityGroupListVo = new SecurityGroupListVo()
          .setSecurityGroupName(10)
          .setCloudServerNum(20)
          .setBareMetalServerNum(10)
          .setComputerGpuNum(10)
          .setComputerGpuBareMetalNum(10)
          .setExclusiveComputerNum(10)
          .setInboundRulesNum(10);
          securityGroupVoList.add(securityGroupListVo);

//数量字段排序操作
SortListUtil<SecurityGroupListVo> groupListVoSortListUtil = new SortListUtil<>();
//云服务器数量
groupListVoSortListUtil.sortByMethod(securityGroupVoList, "getCloudServerNum", true);
//裸金属服务器数量
groupListVoSortListUtil.sortByMethod(securityGroupVoList, "getBareMetalServerNum", true);
//GPU云服务器数量
groupListVoSortListUtil.sortByMethod(securityGroupVoList, "getComputerGpuNum", true);
//GPU裸金属服务器数量
groupListVoSortListUtil.sortByMethod(securityGroupVoList, "getComputerGpuBareMetalNum", true);
//专属宿主机服务器数量
groupListVoSortListUtil.sortByMethod(securityGroupVoList, "getExclusiveComputerNum", true);
//入站规则数量
groupListVoSortListUtil.sortByMethod(securityGroupVoList, "getInboundRulesNum", true);
//出站规则数量
groupListVoSortListUtil.sortByMethod(securityGroupVoList, "getOutboundRulesNum", true);

System.out.println("排序结果："+securityGroupVoList);

总结

如果还是没明白可以观看这篇文章：https://blog.csdn.net/superdog007/article/details/54133698