Java 工具类 —— Java中Map数据处理公共方法MapUtils

---

Map是Java数据类型中的奇迹，我个人非常不喜欢别人用Map或者看用太多Map的代码，但是我太喜欢用Map了，不要问为什么，就是好用。But建议大家在参数传递的时候尽量不要用Map，那样会让自己的代码很难读。下面是我个人使用Map的几点经验写成的公共方法。

完整代码请查看：https://download.csdn.net/download/u011909918/10903906

---

一、HashMap的存储方式

HashMap是数组+链表的形式存储：

数组(主体) --> HashMap是一个key-value键值对数组，地址是由Hash值映射到数组下标;

链表 --> 如果发生Hash冲突则会在某个键值对进行链表存储。

HashMap是散列存储，所以不会记录插入顺序，需要使用LinkHashMap进行排序。

 

二、HashMap排序

这里值介绍使用key排序，通过value排序请参考完整代码：https://download.csdn.net/download/u011909918/10903906

/**
     * Map 按照key排序
     *
     * @param map 需要排序的Map
     * @param method 排序方式，-1为降序， 1为升序
     * @return 排序结果
     *
     * @auth LD
     * @Create date 2018-12-28
     * */
    public static <K extends Comparable<? super K>, V> Map<K, V> sortByKey(Map<K, V> map, int method){
        if (map == null || map.isEmpty()) {
            return null;
        }

        List<Map.Entry<K, V>> linkedList = new LinkedList<>(map.entrySet());
        Collections.sort(linkedList, new Comparator<Map.Entry<K, V>>(){
            @Override
            public int compare(Map.Entry<K, V> map1, Map.Entry<K, V> map2)
            {
                return (map1.getKey().compareTo(map2.getKey())) * method;
            }
        });

        Map<K, V> result = new LinkedHashMap<>();
        for (Map.Entry<K, V> entry : linkedList) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }

三、通过List对HashMap初始化

这里个人用于初始化需要导出的Excel标题

/**
     * 使用List初始化MAP,（个人用来初始化Excel标题）
     *
     * @param keys 需要排序的Map
     * @param values 排序方式，1为降序， -1为升序
     * @return 排序结果
     *
     * @auth LD
     * @Create date 2018-12-28
     * */
    public static <K, V> Map<K, V> initMapByList(List<K> keys, List<V> values){
        if(keys == null || keys.size() == 0){
            return null;
        }
        Map<K, V> result = new LinkedHashMap<>();
        for (int i = 0; i<keys.size(); i++){
            result.put(keys.get(i), values.get(i));
        }
        return result;
    }

四、HashMap遍历（两种方式）

此处仅拷贝一种方式，全部请参考完整代码：https://download.csdn.net/download/u011909918/10903906， 使用方法请参考下方测试代码

/**
     * EntrySet遍历MAP（MAP容量大建议使用）
     *
     * @param map 待遍历的Map
     * @param invoke 操作map数据，实现Invoke中execute方法
     * @return 排序结果
     *
     * @auth LD
     * @Create date 2018-12-28
     * */
    public static <K, V> void ergodicMapByEntrySet(Map<K, V> map, Invoke<K, V> invoke){

        for (Map.Entry<K, V> entry: map.entrySet()) {
            invoke.excute(entry.getKey(), entry.getValue());
        }
    }

    /**
     * Map 操作， 使用时需要实现下面接口的方法
     * */
    public interface Invoke<K, V> {

        void excute(K key, V value);
    }

五、Map<---->对象

map 与 实体对象间的转换

//Map转对象
public static Object mapToObject(Map<String, Object> map, Class<?> beanClass) throws Exception {
		if (map == null)
			return null;

		Object obj = beanClass.newInstance();

		Field[] fields = obj.getClass().getDeclaredFields();
		for (Field field : fields) {
			int mod = field.getModifiers();
			if(Modifier.isStatic(mod) || Modifier.isFinal(mod)){
				continue;
			}

			if(map.get(field.getName()) == null){
				continue;
			}

			field.setAccessible(true);
			if(field.getType().getName().equals("java.lang.Long")){
				field.set(obj, Long.valueOf(map.get(field.getName()) + ""));
			}else if(field.getType().getName().equals("java.lang.Double")){
				field.set(obj, Double.valueOf(map.get(field.getName()) + ""));
			}else if(field.getType().getName().equals("java.lang.Integer")){
				field.set(obj, Integer.valueOf(map.get(field.getName()) + ""));
			}else{
				field.set(obj, map.get(field.getName()));
			}
		}

		return obj;
	}


//对象转Map
public static Map<String, Object> objectToMap(Object obj) throws Exception {    
     if(obj == null){    
         return null;    
     }   

     Map<String, Object> map = new HashMap<String, Object>();    

     Field[] declaredFields = obj.getClass().getDeclaredFields();    
     for (Field field : declaredFields) {    
         field.setAccessible(true);  
         map.put(field.getName(), field.get(obj));  
     }    

     return map;  
 }

六、测试结果

测试方法：

public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "d");
        map.put(2, "a");
        map.put(3, "c");
        map.put(4, "b");

        logger.info("===============================通过value升序排序！！！！");
        map = MapUtils.sortByValue(map, 1);

        MapUtils.ergodicMapByIterator(map, new Invoke<Integer, String>() {
            @Override
            public void excute(Integer key, String value) {
                logger.info("key=" + key + "           value=" + value);
            }
        });

        logger.info("===============================通过value降序排序！！！！");
        map = MapUtils.sortByValue(map, -1);

        MapUtils.ergodicMapByIterator(map, new Invoke<Integer, String>() {
            @Override
            public void excute(Integer key, String value) {
                logger.info("key=" + key + "           value=" + value);
            }
        });

        logger.info("===============================通过key降序排序！！！！");
        map = MapUtils.sortByKey(map, -1);

        MapUtils.ergodicMapByEntrySet(map, new Invoke<Integer, String>() {
            @Override
            public void excute(Integer key, String value) {
                logger.info("key=" + key + "           value=" + value);
            }
        });

        logger.info("===============================通过key升序排序！！！！");
        map = MapUtils.sortByKey(map, 1);

        MapUtils.ergodicMapByEntrySet(map, new Invoke<Integer, String>() {
            @Override
            public void excute(Integer key, String value) {
                logger.info("key=" + key + "           value=" + value);
            }
        });
    }

测试结果：

 

---

欢迎各位大佬指正补充。。。。