java map工具类

import java.lang.reflect.Field;
import java.util.*;

public class ListUtil {
    /**
     *  map根据value排序，升序排列
     *  降序只需要将 compare方法 返回值取反(改成负号)即可
     * @param map  //map集合
     * @return Map
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValueAscending(Map<K, V> map){
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
        list.sort(new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2){
                return (o1.getValue()).compareTo(o2.getValue());
            }
        });
        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }

    /**
     *  map根据value排序
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValueAscending2(Map<K, V> map){
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
        list.sort(new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2){
                return -(o1.getValue()).compareTo(o2.getValue());
            }
        });
        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }

    /**
     *  map根据key排序  升序
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByKeyAscending(Map<K, V> map){
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
        list.sort(new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2){
                return o1.getKey().toString().compareTo(o2.getKey().toString());
            }
        });
        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }
    /**
     *  map根据key排序  升序
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByKeyAscending2(Map<K, V> map){
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
        list.sort(new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2){
                return -o1.getKey().toString().compareTo(o2.getKey().toString());
            }
        });
        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }
    /**
     * list去重 , 适合自定义对象 根据某个属性去重
     *  如 removeSameCustomObjectByAttribute(ListName,Student.class,"name")
     * @param list list集合
     * @param clazz list泛型类  Student.class
     * @param name 去重对象的字段属性
     * @return 去重后的list
     * @throws Exception e
     */
    public static <T> List<T> removeSameCustomObjectByAttribute(List<T> list,Class<?> clazz,String name) throws Exception{
        Field field = clazz.getDeclaredField(name);
        field.setAccessible(true);
        int num = list.size();
        List<T> result = new ArrayList<>(num);
        result.addAll(list);
        for (int i = 0; i < num - 1; i++) {
            for (int j = num - 1; j > i; j--) {
                if (field.get(list.get(j)) == field.get(list.get(i))) {
                    result.remove(list.get(i));
                }
            }
        }
        return result;
    }

     /**
     *  字符串列表去重方法
     * @param list List
     * @return  List
     */
    public static List<String> removeSameForListString(List<String> list){
        List<String> l = new ArrayList<>();
        Set<String> s = new HashSet<>();
        for(String str:list){
            if(s.add(str)){
                l.add(str);
            }
        }
        return l;
    }

    /**
     *  对map的value求和统计
     * @param map Map<String,Integer>
     * @return int
     */
    public static int getMapCountValue(Map<String,Integer> map){
        int count=0;
        for(String str:map.keySet()){
            count = count+map.get(str);
        }
        return count;
    }

    /**
     *  返回 map中值最大的key
     * @param map Map<String, Integer>
     * @return String
     */
    public static String getMaxValue(Map<String, Integer> map) {
        List<Map.Entry<String, Integer>> list= new ArrayList<>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                return o2.getValue().compareTo(o1.getValue());
            }
        });
        //获取最大的概率对应的key值
        String key="";
        for (Map.Entry<String, Integer> mapping : list) {
            key=mapping.getKey();
            break;
        }
        return key;
    }

    /**
     *  返回 map中值最大的value
     * @param map Map<String, Integer>
     * @return String
     */
    public static String getMaxValue_value(Map<String, Integer> map) {
        List<Map.Entry<String, Integer>> list= new ArrayList<>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                return o2.getValue().compareTo(o1.getValue());
            }
        });
        //获取最大的概率对应的key值
        int key=0;
        for (Map.Entry<String, Integer> mapping : list) {
            key=mapping.getValue();
            break;
        }
        return key+"";
    }

}