Java Map工具类

package waf.util;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import waf.convert.Conv;

/**
 * 
 * @author waf.wang
 *
 */
public class MapUtil
{

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub

    }

    @SuppressWarnings("unchecked")
    public static void cut(Map srcMap,Map dstMap,Object key)
    {
        Object obj=srcMap.remove(key);
        if(obj!=null)
        {
            dstMap.put(key,obj);
        }
    }

    public static void print(Map map)
    {
        for(Object key:map.keySet())
        {
            System.out.println("key="+key+"; value="+map.get(key));
        }
    }

    public static <ValueT> Map<String,ValueT> sortByKey(Map<String,ValueT> map)
    {
        Map<String,ValueT> ret=new LinkedHashMap<String,ValueT>();

        List<String> keys=Conv.set2List(map.keySet());

        Collections.sort(keys);

        for(String key:keys)
        {
            ret.put(key,map.get(key));
        }
        keys.clear();
        return ret;
    }
    
    public static <ValueT> Map<Integer,ValueT> sortByIntegerKey(Map<Integer,ValueT> map)
    {
        Map<Integer,ValueT> ret=new LinkedHashMap<Integer,ValueT>();

        List<Integer> keys=Conv.set2List(map.keySet());

        Collections.sort(keys);

        for(Integer key:keys)
        {
            ret.put(key,map.get(key));
        }
        keys.clear();
        return ret;
    }
    
//    public static String md5(Map<String,String> map)
//    {
//        String ret="";
//        
//        String str="";
//        for (String key:map.keySet()) 
//        {
//            str+=key+":"+map.get(key)+";";
//        }
//        return ret;
//    }

    // public static Map<String,Long> sortByValue(Map<String,Long> map)
    // {
    // List<Map.Entry<String,Long>> wordFrenList=new ArrayList(map.entrySet());
    //
    // Collections.sort(wordFrenList,new Comparator<Map.Entry<String,Long>>()
    // {
    // public int compare(Map.Entry<String,Long> obj1,Map.Entry<String,Long>
    // obj2)
    // {
    // return (int)(obj2.getValue()-obj1.getValue());
    // }
    // });
    //        
    // return null;
    // }

    @SuppressWarnings("unchecked")
    public static <KeyT> List<Map.Entry<KeyT,Long>> sortByLongValue(Map<KeyT,Long> map)
    {
        List<Map.Entry<KeyT,Long>> list=new ArrayList(map.entrySet());

        Collections.sort(list,new Comparator<Map.Entry<KeyT,Long>>()
        {
            public int compare(Map.Entry<KeyT,Long> obj1,Map.Entry<KeyT,Long> obj2)
            {
                return (int)(obj2.getValue()-obj1.getValue());
            }
        });
        return list;
    }

    @SuppressWarnings("unchecked")
    public static <KeyT> List<Map.Entry<KeyT,Integer>> sortByIntegerValue(Map<KeyT,Integer> map)
    {
        List<Map.Entry<KeyT,Integer>> list=new ArrayList(map.entrySet());

        Collections.sort(list,new Comparator<Map.Entry<KeyT,Integer>>()
        {
            public int compare(Map.Entry<KeyT,Integer> obj1,Map.Entry<KeyT,Integer> obj2)
            {
                return (int)(obj2.getValue()-obj1.getValue());
            }
        });
        return list;
    }

    /** key改名，不创建新map,但是被改名的key的输出顺序会被更改 */
    public static <ValueT> void renameKey(Map<String,ValueT> map,String oldKey,String newKey)
    {
        ValueT value=map.remove(oldKey);
        if(value!=null)
        {
            map.put(newKey,value);
        }
    }

    /** key改名，不创建新map,但是被改名的key的输出顺序会被更改 */
    public static <ValueT> void renameKey(List<Map<String,ValueT>> list,String oldKey,String newKey)
    {
        for(Map<String,ValueT> map:list)
        {
            renameKey(map,oldKey,newKey);
        }
    }

    public static String getKeyByValue(Map map,Object value)
    {

        String keys="";

        Iterator it=map.entrySet().iterator();

        while(it.hasNext())
        {
            Map.Entry entry=(Entry)it.next();

            Object obj=entry.getValue();

            if(obj!=null&&obj.equals(value))
            {
                keys=(String)entry.getKey();
                break;
            }
        }
        return keys;
    }
    
    @SuppressWarnings("unchecked")
    public static void copy(Map src,Map dest,Object key)
    {
        dest.put(key,src.get(key));
    }
    
    @SuppressWarnings("unchecked")
    public static void copy(Map src,Map dest,Object srcKey,Object dstKey)
    {
        dest.put(dstKey,src.get(srcKey));
    }
    
    public static void compare(Map<String,Object> map1,Map<String,Object> map2)
    {
        for(Map.Entry<String,Object> entry1:map1.entrySet())
        {
//            Object m1value=entry1.getValue()==null?"":entry1.getValue();
//            Object m2value=map2.get(entry1.getKey())==null?"":map2.get(entry1.getKey());
            if(!entry1.getValue().equals(map2.get(entry1.getValue())))
            {
                System.out.println(entry1.getKey()+","+entry1.getValue()+","+map2.get(entry1.getValue()));
            }
        }
    }
}