Collection工具（MapList指定字段排序排名、Map通过K或V排序、获取Map中第一个非空数据值）

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.text.TextSimilarity;

import java.text.Collator;
import java.util.*;
import java.util.stream.Collectors;

import java.lang.reflect.Field;

/**
 * 

 * map工具 集合
 * 
 *
 * @Author REID
 * @Blog https://blog.csdn.net/qq_39035773
 * @GitHub https://github.com/BeginnerA
 * @Data 2020/11/6
 * @Version V1.0
 **/
public final class MapTools {

    /**
     * 相似度，为了匹配的准确度相似度值最少在0.8以上
     */
    private static final double SIMILARITY = 0.9;

    /**
     * map 按 key 升序排序
     * @param map 需排序map
     * @param  K
     * @param  V
     * @return 升序后的map
     */
    public static , V>Map sortByKey(Map map) {
        return sortByKey(map, false);
    }

    /**
     * map 按 key 降序排序
     * @param map 需排序map
     * @param  K
     * @param  V
     * @return 降序后的map
     */
    public static , V>Map sortByKeyDesc(Map map) {
        return sortByKey(map, true);
    }

    /**
     * map 按 key 升序排序
     * @param map 需排序map
     * @param  K
     * @param  V
     * @return 升序后的map
     */
    public static >Map sortByValue(Map map) {
        return sortByValue(map, false);
    }

    /**
     * map 按 key 降序排序
     * @param map 需排序map
     * @param  K
     * @param  V
     * @return 降序后的map
     */
    public static >Map sortByValueDesc(Map map) {
        return sortByValue(map, true);
    }

    /**
     * map 按 key 升序排序
     * @param map 需排序map
     * @param isDesc 是否降序：true：降序，false：升序
     * @return 排序后的map
     */
    private static , V>Map sortByKey(Map map, boolean isDesc) {
        Map result = new LinkedHashMap<>(map.size());
        if (isDesc) {
            map.entrySet().stream()
                    .sorted(Map.Entry.comparingByKey())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        }else {
            map.entrySet().stream()
                    .sorted(Map.Entry.comparingByKey().reversed())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        }

        return result;
    }

    /**
     * 根据map的value排序
     * @param map 待排序的map
     * @param isDesc 是否降序：true：降序，false：升序
     * @return 排序好的map
     */
    private static >Map sortByValue(Map map, boolean isDesc) {
        Map result = new LinkedHashMap<>(map.size());
        if (isDesc) {
            map.entrySet().stream()
                    .sorted(Map.Entry.comparingByValue().reversed())
                    .forEach(e -> result.put(e.getKey(), e.getValue()));
        } else {
            map.entrySet().stream()
                    .sorted(Map.Entry.comparingByValue())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        }
        return result;
    }

    /**
     * 指定排序字段对 mapList 升序排序
     * @param mapList mapList
     * @param sortField 排序字段
     */
    public static  void sortMapListAsc(List> mapList, String sortField) {
        sortMapList(mapList, sortField, false);
    }

    /**
     * 指定排序字段对 mapList 降序排序
     * @param mapList mapList
     * @param sortField 排序字段
     */
    public static  void sortMapListDesc(List> mapList, String sortField) {
        sortMapList(mapList, sortField, true);
    }

    /**
     * 指定排序字段对 mapList 排序
     * @param mapList mapList
     * @param sortField 排序字段
     * @param isDesc 是否降序：true：降序，false：升序
     */
    private static  void sortMapList(List> mapList, String sortField, boolean isDesc) {
        mapList.sort(new Comparator>() {
            @Override
            public int compare(Map o1, Map o2) {
                String v1 = o1.get(sortField).toString();
                String v2 = o2.get(sortField).toString();
                if (isDesc) {
                    try {
                        return Integer.valueOf(v2).compareTo(Integer.valueOf(v1));
                    }catch (NumberFormatException e) {
                        // 不是数值类型将 mapList 集合按照 Map 的 name 进行排序(c>b>a ...)
                        Collator instance = Collator.getInstance(Locale.CHINA);
                        return instance.compare(v2, v1);
                    }
                }else {
                    try {
                        return Integer.valueOf(v1).compareTo(Integer.valueOf(v2));
                    }catch (NumberFormatException e) {
                        // 不是数值类型将 mapList 集合按照 Map 的 name 进行排序(a>b>c ...)
                        Collator instance = Collator.getInstance(Locale.CHINA);
                        return instance.compare(v1, v2);
                    }
                }
            }
        });
    }

    /**
     * 获取map中第一个非空数据值
     *
     * @param  Key的类型
     * @param  Value的类型
     * @param map 数据源
     * @return 返回的值
     */
    public static  V getFirstNotNull(Map map) {
        V obj = null;
        for (Map.Entry entry : map.entrySet()) {
            obj = entry.getValue();
            if (obj != null) {
                break;
            }
        }
        return obj;
    }

    /**
     * 获取Map中value相似度大于{@link #SIMILARITY}的key
     * @param map Map
     * @param reference 参考值
     * @return 相似度最大的key
     */
    public static  K similarKey(Map map, String reference) {
        return similarKey(map, reference, SIMILARITY);
    }

    /**
     * 获取Map中value相似度大于{@link #SIMILARITY}的key
     * @param map Map
     * @param reference 参考值
     * @param similarity 相似度：最大1.0，最小是0.0
     * @return 相似度最大的key
     */
    public static  K similarKey(Map map, String reference, double similarity) {
        Map m = new HashMap<>(map.size());
        for (K key : map.keySet()) {
            double similar = TextSimilarity.similar(Convert.toStr(map.get(key)), reference);
            if (similar == 1) {
                return key;
            }else if (similar > similarity) {
                m.put(similar, key);
            }
        }
        if (CollUtil.isEmpty(m)) {
            return null;
        }
        return getFirstNotNull(sortByKey(m));
    }

    /**
     * mapList转Map
     * @param mapList mapList
     * @param keyField Map Key字段
     * @param valueField Map value字段
     * @param  key
     * @param  value
     * @return 转后的Map
     */
    public static  Map listMapToMap(List> mapList, String keyField, String valueField) {
        return mapList.stream().collect(Collectors.toMap(m-> Convert.toStr(m.get(keyField)), m->m.get(valueField)));
    }

    /**
     * 对象转 Map
     * @param object 对象
     * @return Map
     */
    public static Map objectToMap(Object object){
        Map dataMap = new HashMap<>();
        Class clazz = object.getClass();
        for (Field field : clazz.getDeclaredFields()) {
            try {
                field.setAccessible(true);
                dataMap.put(field.getName(),field.get(object));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return dataMap;
    }

    /**
     * 对 mapList 通过指定 Map key 排名
     * @param mapList mapList
     * @param rankField Map key 排名字段
     * @return 新的有排名字段的 mapList
     */
    public static List> rank(List> mapList, String rankField) {
        List>>> entries = mapList.stream().collect(Collectors.groupingBy(m -> Convert.toDouble(m.get(rankField)))).entrySet().stream().sorted((s1, s2) -> -Double.compare(s1.getKey(), s2.getKey())).collect(Collectors.toList());
        // 设置排名
        int rank = 1;
        // 设置排序号
        int index = 1;
        for (Map.Entry>> entry : entries) {
            for (Map map : entry.getValue()) {
                map.put("rank", rank);
                map.put("index", index++);
            }
            rank++;
        }
        return mapList;
    }

    /**
     * 循环截取某页列表
     * @param dataList 分页数据
     * @param pageSize 页面大小
     * @param currentPage 当前页面
     */
    public static  List page(List dataList, int pageSize, int currentPage) {
        List currentPageList = new ArrayList<>();
        if (dataList != null && dataList.size() > 0) {
            int currIdx = (currentPage > 1 ? (currentPage - 1) * pageSize : 0);
            for (int i = 0; i < pageSize && i < dataList.size() - currIdx; i++) {
                T data = dataList.get(currIdx + i);
                currentPageList.add(data);
            }
        }
        return currentPageList;
    }
}