JAVA List<Map>结果集处理方法集合

import org.apache.commons.lang.ObjectUtils;

import java.util.*;

/**
 * Created by hurf on 2015/10/12.
 */
public class ListMapUtil {
      /**
     * 比较数组内容是否相等
     * @return
     */
    public static boolean compareArray(Object[] ary1,Object[] ary2){
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();
        for (int i = 0,len1=ary1.length; i <len1 ; i++) {
            list1.add(ObjectUtils.toString(ary1[i]));
        }
        for (int i = 0,len2=ary2.length; i <len2 ; i++) {
            list2.add(ObjectUtils.toString(ary2[i]));
        }
        Object[] as1 = list1.toArray();
        Object[] as2 = list2.toArray();
        Arrays.sort(as1);
        Arrays.sort(as2);
        return Arrays.equals(as1, as2);
    }

    /**
     * 取出结果集List<Map>中的某一列，组合成数组
     * @return
     */
    public static String[] getArray(List<Map> result,String columnName){
        List<String> strList = new ArrayList<String>();
        for (int i = 0,len = result.size(); i < len; i++) {
            strList.add(ObjectUtils.toString(result.get(i).get(columnName)));
        }
        return (String[])strList.toArray();
    }

    /**
     * 取出结果集List<Map>中的某一列，组合成List<String>
     * @param result
     * @param columnName
     * @return
     */
    public static List<String> getListStr(List<Map> result,String columnName){
        List<String> strList = new ArrayList<String>();
        for (int i = 0,len = result.size(); i < len; i++) {
            strList.add(ObjectUtils.toString(result.get(i).get(columnName)));
        }
        return strList;
    }

    /**
     * 内存结果集查询，支持 = 和 IN 查询
     * @param lm  未处理的结果集
     * @param conditionColumn 多个查询条件{"KEY1":"VALUE1","KEY2":"VALUE2"}
     * @return
     */
    public static List<Map> getListMap(List<Map> lm,Map<String,Object> conditionColumn){
        if(lm.isEmpty()||lm.size()<=0){
            return lm;
        }
        if(conditionColumn.size()==0){
            return lm;
        }
        Map newConMap = new HashMap(conditionColumn);
        for (String key:conditionColumn.keySet()){
            List<Map> curList = new ArrayList<Map>();
            Object value = conditionColumn.get(key);
            if(value instanceof String){
                List<Map> mList = getListMap(lm,key,ObjectUtils.toString(value));
                for (int i = 0,ilen = mList.size(); i < ilen; i++) {
                    curList.add(mList.get(i));
                }
            }else if(value instanceof String[]){
                List<Map> mList = getListMap(lm,key,(String[])value);
                for (int i = 0,ilen = mList.size(); i < ilen; i++) {
                    curList.add(mList.get(i));
                }
            }else if(value instanceof List){
                List<Map> mList = getListMap(lm,key,(List<String>)value);
                for (int i = 0,ilen = mList.size(); i < ilen; i++) {
                    curList.add(mList.get(i));
                }
            }
            newConMap.remove(key);
            getListMap(curList, newConMap);
        }
        return lm;
    }

    /**
     * 内存结果集查询，支持不等于号
     * @param lm
     * @param conditionColumnName
     * @param compareStr (数据库字段值 比较 入参)
     *                   MORE_THAN  ：dbValue（数据库值）>  conditionColumnValue（入参）
     *                   LESS_THAN  ：dbValue（数据库值）<  conditionColumnValue（入参）
     *                   MORE_EQUAL：dbValue（数据库值） >= conditionColumnValue（入参）
     *                   LESS_EQUAL：dbValue（数据库值） <= conditionColumnValue（入参）
     * @param conditionColumnValue
     * @return
     */
    public static List<Map> getListMap(List<Map> lm,String conditionColumnName,String compareStr,String conditionColumnValue){
        List<Map> strList = new ArrayList<Map>();
        if(">".equals(compareStr)){
            for (int i = 0,len = lm.size(); i < len; i++) {
                Map map = lm.get(i);
                String dbValue = ObjectUtils.toString(map.get(conditionColumnName));
                if(Double.valueOf(dbValue)>Double.valueOf(conditionColumnValue)){
                    strList.add(map);
                }
            }
        }else if("<".equals(compareStr)){
            for (int i = 0,len = lm.size(); i < len; i++) {
                Map map = lm.get(i);
                String dbValue = ObjectUtils.toString(map.get(conditionColumnName));
                if(Double.valueOf(dbValue)<Double.valueOf(conditionColumnValue)){
                    strList.add(map);
                }
            }
        }else if("<=".equals(compareStr)){
            for (int i = 0,len = lm.size(); i < len; i++) {
                Map map = lm.get(i);
                String dbValue = ObjectUtils.toString(map.get(conditionColumnName));
                if(Double.valueOf(dbValue) <= Double.valueOf(conditionColumnValue)){
                    strList.add(map);
                }
            }
        }else if(">=".equals(compareStr)){
            for (int i = 0,len = lm.size(); i < len; i++) {
                Map map = lm.get(i);
                String dbValue = ObjectUtils.toString(map.get(conditionColumnName));
                if(Double.valueOf(dbValue) >= Double.valueOf(conditionColumnValue)){
                    strList.add(map);
                }
            }
        }
        return strList;
    }

    /**
     * 根据条件字段获取 指定结果集 中的符合条件的行 (只支持单个条件)
     * @param lm
     * @param conditionColumnName
     * @return
     */
    public static List<Map> getListMap(List<Map> lm,String conditionColumnName,String conditionColumnValue){
        List<Map> strList = new ArrayList<Map>();
        for (int i = 0,len = lm.size(); i < len; i++) {
            Map map = lm.get(i);
            String dbValue = ObjectUtils.toString(map.get(conditionColumnName)).trim();//结果集中的实际值
            if(dbValue.equals(conditionColumnValue)){
                strList.add(map);
            }
        }
        return strList;
    }

    /**
     * 根据对应字段，获取所有变更的一条记录
     * @param lm
     * @param conditionColumnName
     * @param conditionColumnValue
     * @return
     */
    public static Map getPutAllMap(List<Map> lm,String conditionColumnName,String conditionColumnValue){
        Map putAllMap = new HashMap();
        for (int i = 0,len = lm.size(); i < len; i++) {
            Map map = lm.get(i);
            String dbValue = ObjectUtils.toString(map.get(conditionColumnName)).trim();//结果集中的实际值
            if(dbValue.equals(conditionColumnValue)){
                putAllMap.putAll(map);
            }
        }
        return putAllMap;
    }

    /**
     * 支持 IN查询
     * @param lm
     * @param conditionColumnName
     * @param  conditionColumnValues String[]
     * @return
     */
    public static List<Map> getListMap(List<Map> lm,String conditionColumnName,String[] conditionColumnValues){
        List<Map> strList = new ArrayList<Map>();
        for (int i = 0,clen = conditionColumnValues.length; i < clen; i++) {
            for (int j = 0,len = lm.size(); j < len; j++) {
                Map map = lm.get(j);
                String dbValue = ObjectUtils.toString(map.get(conditionColumnName));//结果集中的实际值
                if(dbValue.equals(conditionColumnValues[i])){
                    strList.add(map);
                }
            }
        }
        return strList;
    }

    /**
     * 支持 IN查询
     * @param lm
     * @param conditionColumnName
     * @param  conditionColumnValues List<String>
     * @return
     */
    public static List<Map> getListMap(List<Map> lm,String conditionColumnName,List<String> conditionColumnValues){
        List<Map> strList = new ArrayList<Map>();
        for (int i = 0,clen = conditionColumnValues.size(); i < clen; i++) {
            for (int j = 0,len = lm.size(); j < len; j++) {
                Map map = lm.get(j);
                String dbValue = ObjectUtils.toString(map.get(conditionColumnName));//结果集中的实际值
                if(dbValue.equals(conditionColumnValues.get(i))){
                    strList.add(map);
                }
            }
        }
        return strList;
    }

  /**
     * 去重：根据指定唯一字段去重(指定的字段就是 类似主键字段)
     * @param duListMap
     * @param keys
     * @return 调用实例：deleteDuplicate(duListMap,"BIZ_SNO"); //删除结果集中BIZ_SNO是重复的Map
     */
    public static List<Map> deleteDuplicate(List<Map> duListMap,String... keys){
        int keyLen = keys.length;
        if(keyLen==1){//只考虑一个Key为唯一字段的情况
            String firstKey = ObjectUtils.toString(keys[0]);
            for (int i = 0,len=duListMap.size(); i < len; i++) {
                for  ( int j= len-1; j > i; j-- )   {
                    if  (compareByKey(duListMap, firstKey, i, j))   {
                        duListMap.remove(j);
                    }
                }
            }
        }else{//比较所有指定的Key的值，相当于联合主键
            for (int ki = 0; ki < keyLen; ki++) {
                String key =  ObjectUtils.toString(keys[ki]);
                for (int i = 0,len=duListMap.size(); i < len; i++) {
                    for  ( int j= len-1; j > i; j-- )   {
                        if  (compareByKey(duListMap, key, i, j)) {
                            duListMap.remove(j);
                        }
                    }
                }
            }
        }
        return duListMap;
    }

    private static boolean compareByKey(List<Map> duListMap, String firstKey, int i, int j) {
        return ObjectUtils.toString(duListMap.get(j).get(firstKey)).equals(ObjectUtils.toString(duListMap.get(i).get(firstKey)));
    }

      /**
     * 合并List<Map> 结果集
     * @param listMaps
     * @return
     */
    public static List<Map> mergeListMap(List<Map> ...listMaps){
        List<Map> rsListMap = new ArrayList<Map>();
        for (List<Map> listMap:listMaps){
            for (Map m:listMap){
                rsListMap.add(m);
            }
        }
        return rsListMap;
    }

    /**
     * 将两个结果集用一个关联字段进行关联，形成一个新的结果集(以第一个结果集为主)
     * @param baseList
     * @param relList
     * @param col
     */
    public static List<Map> mergeListMapsByCol(List<Map> baseList, List<Map> relList, String col) {
        List<Map> rlist = new ArrayList<Map>();
        for (Map bMap:baseList) {
            String colVal = ObjectUtils.toString(bMap.get(col));
            boolean addFlag = true;
            for (Map rMap:relList) {
                if(ObjectUtils.toString(rMap.get(col)).equals(colVal)){
                    rMap.putAll(bMap);
                    rlist.add(rMap);
                    rMap.put("REGISTER_NO",ObjectUtils.toString(rMap.get("BUSINESS_LICENCE_NO")));
                    rMap.put("REGISTER_TYPE","1");
                    rMap.put("COUNTRY_REVENUE",ObjectUtils.toString(rMap.get("BUSINESS_TAX_NO")));
                    rMap.put("COUNTRY_REVENUE_EXP",ObjectUtils.toString(rMap.get("TAX_NO_EXP_DATE")));
                    rMap.put("ORG_CODE",ObjectUtils.toString(rMap.get("ORG_ID_CODE")));
                    rMap.put("ORG_CODE_EXPDATE",ObjectUtils.toString(rMap.get("ORG_ID_EXP_DATE")));
                    addFlag = false;
                }
            }
            if(addFlag){
                rlist.add(bMap);
            }
        }
        return  rlist;
    }
  }