对集合list实体对象某字段进行排序（两种方法）

将集合list中的实体对象按照某字段来排序

1、第一种方法：（利用反射）示例代码：

import lombok.extern.slf4j.Slf4j;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;

/**
 * ClassName: SortList
 * Function:  list升降排序专用
 * Date:      2021-04-21
 * method: age
 * sort:desc/asc
 */
@Slf4j
public class SortList<E> {
    public  void Sort(List<E> list, final String method, final String sort) {
        Collections.sort(list, new Comparator<E>() {
            @Override
            public int compare(Object a, Object b) {
                double ret = 0;
                try {
                    Class c = a.getClass();
                    List<Field> fieldList = new ArrayList<>() ;
                    while (c != null) {//当父类为null的时候说明到达了最上层的父类(Object类).
                        fieldList.addAll(Arrays.asList(c .getDeclaredFields()));
                        c = c.getSuperclass(); //得到父类,然后赋给自己
                    }
                    //循环获得字段对象field
                    Field field = null;
                    Iterator<Field> iterator = fieldList.iterator();
                    while (iterator.hasNext()) {
                        field = iterator.next();
                        String fieldName = field.getName();
                        if (fieldName.equals(method)) {
                            break;
                        }
                    }
                    String classType = field.getType().getSimpleName();
                    String getFieldMethod = "get" + method.substring(0, 1).toUpperCase() + method.substring(1);
                    Method m1 = ((E) a).getClass().getMethod(getFieldMethod, null);
                    Method m2 = ((E) b).getClass().getMethod(getFieldMethod, null);
                    if ("String".equals(classType)) {
                        if (sort != null && "desc".equals(sort)) {
                            //倒序
                            ret = ((String)m2.invoke(((E) b), null)).compareTo((String) m1.invoke(((E) a), null));
                        } else {
                            //正序
                            ret = ((String) m1.invoke(((E) a), null)).compareTo((String) m2.invoke(((E) b), null));
                        }
                    } else if ("Integer".equals(classType) || "int".equals(classType)) {
                        if (sort != null && "desc".equals(sort)) {
                            ret = ((Integer) (m2.invoke(((E) b), null)))
                                    - ((Integer) (m1.invoke(((E) a), null)));
                        } else {
                            ret = ((Integer) m1.invoke(((E) a), null))
                                    - ((Integer) (m2.invoke(((E) b), null)));
                        }
                    } else if ("Double".equals(classType) || "double".equals(classType)) {
                        if (sort != null && "desc".equals(sort)) {
                            ret = ((Double) (m2.invoke(((E) b), null)))
                                    - ((Double) (m1.invoke(((E) a), null)));
                        } else {
                            ret = ((Double) m1.invoke(((E) a), null))
                                    - ((Double) (m2.invoke(((E) b), null)));
                        }
                    } else if ("Float".equals(classType) || "float".equals(classType)) {
                        if (sort != null && "desc".equals(sort)) {
                            ret = ((Float) (m2.invoke(((E) b), null)))
                                    - ((Float) (m1.invoke(((E) a), null)));
                        } else {
                            ret = ((Float) m1.invoke(((E) a), null))
                                    - ((Float) (m2.invoke(((E) b), null)));
                        }
                    } else {
                        System.out.println("属性排序只支持数据类型和String类型，其它类型暂不支持。");
                        ret = -100;
                    }
                } catch (Exception ne) {
                    System.out.println("**error:" + ne.getMessage());
                }
            // 确定返回值
                if (ret > 0) {
                    return 1;
                } else if (ret < 0) {
                    return -1;
                }
                return 0;
            }
        });
    }



}

2、第二种方法：使用list的sort重写比较方法实现

List<ContentTopicGroupQryRespVo> list = new ArrayList();
//用此方法排序（默认升序，倒叙需要使用reverse方法）
   list.sort(Comparator.comparing(
           (ContentTopicGroupQryRespVo v)->{
               return v.getTopicCount();
           }
   ));
   
   //不确定字段反射获取，反射比较
   String getFieldMethod = "get" + sortBy.substring(0, 1).toUpperCase() + sortBy.substring(1);
   list.sort(Comparator.comparing(
           (ContentTopicGroupQryRespVo v) -> {
               try {
                   Method c = v.getClass().getMethod(getFieldMethod, null);
                   return (Integer) (c.invoke(v, null));
               }catch (Exception e){
                   //默认升序
                   return 1;
               }
           }
   ));

 //倒序使用reverse方法
   list.sort(Comparator.comparing(
           (ContentTopicGroupQryRespVo v)->{
               return v.getTopicCount();
           }
   ).reversed());

//若实现多个字段（topicCount,createdAt）进行排序，使用thenComparing拼接实现，示例代码：
   list.sort(Comparator.comparing(
           (ContentTopicGroupQryRespVo v)->{
               return v.getTopicCount();
           }
   ).thenComparing(
           (ContentTopicGroupQryRespVo v)->{
               return v.getCreatedAt();
           }
   ));