根据key或value将map容器进行排序

java中的HashMap是无序的，有序容器可用LinkedHashMap
在cmopare接口中，Integer或者Date通过compareTo方法进行对象比较时，“比较对象” 比 “被比较对象” 大时返回-1，相等时返回0，小则返回1。

/**
     * 将容器按照日期、数字等类型的键，排序
     * @return
     * @param map
     * @param orderRule 0为升序，1为降序
     * @param keyType 0为数字类型  1为日期类型
     */
    private static Map containerSortByKey(Map map, Integer keyType, Integer orderRule){
    
    
        if(ConstantHelper.NUMBER_0 == keyType){
    
    
            List<Map.Entry<Integer, Object>> infoIds = new ArrayList<Map.Entry<Integer, Object>>(map.entrySet());
            Collections.sort(infoIds, new Comparator<Map.Entry<Integer, Object>>() {
    
    
                @Override
                public int compare(Map.Entry<Integer, Object> o1, Map.Entry<Integer, Object> o2) {
    
    
                    return ConstantHelper.NUMBER_0 == orderRule?o1.getKey().compareTo(o2.getKey()):o2.getKey().compareTo(o1.getKey());
                }
            });
        }else if(ConstantHelper.NUMBER_1 == keyType){
    
    
            List<Map.Entry<Date, Object>> infoIds = new ArrayList<Map.Entry<Date, Object>>(map.entrySet());
            Collections.sort(infoIds, new Comparator<Map.Entry<Date, Object>>() {
    
    
                @Override
                public int compare(Map.Entry<Date, Object> o1, Map.Entry<Date, Object> o2) {
    
    
                    return ConstantHelper.NUMBER_0 == orderRule?o1.getKey().compareTo(o2.getKey()):o2.getKey().compareTo(o1.getKey());
                }
            });
        }
        return map;
    }

    /**
     * 将容器按照日期、数字等类型的值，排序
     * @param map
     * @param valueType 0为数字类型  1为日期类型
     * @param orderRule 0为升序，1为降序
     * @return
     */
    public static Map containerSortByValue(Map map,Integer valueType,Integer orderRule){
    
    
        if(ConstantHelper.NUMBER_0 == valueType){
    
    
            List<Map.Entry<Object, Integer>> valueList = new LinkedList<Map.Entry<Object, Integer>>(map.entrySet());
            Collections.sort(valueList, new Comparator<Map.Entry<Object, Integer>>() {
    
    
                @Override
                public int compare(Map.Entry<Object, Integer> o1,Map.Entry<Object, Integer> o2) {
    
    
                    return ConstantHelper.NUMBER_0 == orderRule ? o1.getValue().compareTo(o2.getValue()):o2.getValue().compareTo(o1.getValue());
                }
            });
            HashMap<Object,Integer> resultMap =new LinkedHashMap<>();
            for(Map.Entry<Object, Integer> entry:valueList){
    
    
                resultMap.put(entry.getKey(),entry.getValue());
            }
            return resultMap;
        }else if(ConstantHelper.NUMBER_1 == valueType){
    
    
            List<Map.Entry<Object, Date>> valueList = new LinkedList<Map.Entry<Object, Date>>(map.entrySet());
            Collections.sort(valueList, new Comparator<Map.Entry<Object, Date>>() {
    
    
                @Override
                public int compare(Map.Entry<Object, Date> o1,Map.Entry<Object, Date> o2) {
    
    
                     return ConstantHelper.NUMBER_0 == orderRule ?(o1.getValue().compareTo(o2.getValue())):(o2.getValue().compareTo(o1.getValue()));
            });
            HashMap<Object,Date> resultMap =new LinkedHashMap<>();
            for(Map.Entry<Object, Date> entry:valueList){
    
    
                resultMap.put(entry.getKey(),entry.getValue());
            }
            return resultMap;
        }else {
    
    
            return null;
        }
    }