对List<Map>相同的key值的数据进行特殊处理

Question

想在有如下的一个集合数据

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestListMap {

    // 初始化List<Map<String, String>>
    public static List<Map<String, String>> init() {
        List<Map<String, String>> lists = new ArrayList<Map<String, String>>();

        Map<String, String> map0 = new HashMap<String, String>();
        map0.put("dtime", "20170101");
        map0.put("ua", "110.5");
        lists.add(map0);
        Map<String, String> map1 = new HashMap<String, String>();
        map1.put("dtime", "20170101");
        map1.put("ua", "220.3");
        lists.add(map1);
        Map<String, String> map2 = new HashMap<String, String>();
        map2.put("dtime", "20170102");
        map2.put("ua", "110");
        lists.add(map2);
        Map<String, String> map3 = new HashMap<String, String>();
        map3.put("dtime", "20170102");
        map3.put("ua", "220.32");
        lists.add(map3);
        Map<String, String> map4 = new HashMap<String, String>();
        map4.put("dtime", "20170103");
        map4.put("ua", "110");
        lists.add(map4);
        Map<String, String> map5 = new HashMap<String, String>();
        map5.put("dtime", "20170103");
        map5.put("ua", "220.32");
        lists.add(map5);

        return lists;
    }

    public static void main(String[] args) {
        
        // 初始化集合
        List<Map<String, String>> list = init();
    }
}

需要计算出同一个时间段之内  ua 在 198~235.4 之间的  占比。

各位大神，有什么好点的方法去解决这个问题吗？

Answer 1

问题我自己已经找到了完整的解决方案，现在附上代码。有问题，或者有更好的解决方案  欢迎交流的。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestListMap {

    // 初始化List<Map<String, Object>>
    public static List<Map<String, Object>> init() {
        List<Map<String, Object>> lists = new ArrayList<Map<String, Object>>();

        Map<String, Object> map0 = new HashMap<String, Object>();
        map0.put("dtime", "20170101");
        map0.put("ua", "220");
        lists.add(map0);
        
        Map<String, Object> map1 = new HashMap<String, Object>();
        map1.put("dtime", "20170101");
        map1.put("ua", "220");
        lists.add(map1);
        
        Map<String, Object> map2 = new HashMap<String, Object>();
        map2.put("dtime", "20170102");
        map2.put("ua", "220");
        lists.add(map2);
        
        Map<String, Object> map3 = new HashMap<String, Object>();
        map3.put("dtime", "20170102");
        map3.put("ua", "224");
        lists.add(map3);
        
        Map<String, Object> map4 = new HashMap<String, Object>();
        map4.put("dtime", "20170103");
        map4.put("ua", "220");
        lists.add(map4);
        
        Map<String, Object> map5 = new HashMap<String, Object>();
        map5.put("dtime", "20170103");
        map5.put("ua", "110");
        lists.add(map5);

        return lists;
    }

    public static void main(String[] args) {
        
        // 初始化数据
        List<Map<String, Object>> list = init();
        
        // 对原有数据进行解析
        List<Map<String, Object>> dataList = hasData(list);
        
        // 对处理过后的数据计算 占比
        List<Object> pageList = handleData(dataList);
        
        System.out.println(pageList.toString());
    }
    
    /**
     * 转换原有数据
     * @param list
     * @return
     */
    public static List<Map<String, Object>> hasData(List<Map<String, Object>> list){
        
        List<Map<String, Object>> resutlList = new ArrayList<Map<String, Object>>();
        
        for (int i = 0; i < list.size(); i++) {

            int flag = 0;// 0为新增数据，1为处理数据
            for (int j = 0; j < resutlList.size(); j++) {

                if (list.get(i).get("dtime")
                        .equals(resutlList.get(j).get("dtime"))) {
                    
                    // 时间不为空总数 +1
                    resutlList.get(j).put(
                            "countSum",
                            Integer.valueOf(resutlList.get(j).get("countSum")
                                    .toString()) + 1);
                    
                    double ua = stringToDouble(list.get(i).get("ua"));
                    
                    // ua的数据满足添加 +1
                    if(ua > 198 && ua < 235.4){
                        resutlList.get(j).put(
                                "countHg",
                                Integer.valueOf(resutlList.get(j).get("countHg")
                                        .toString()) + 1);
                    }
                    
                    flag = 1;
                }
            }
            if (flag == 0) {

                Map<String, Object> map = list.get(i);
                
                // 记录初始 总数
                map.put("countSum", 1);

                // 记录满足 条件的数据
                if (stringToDouble(map.get("ua")) > 198
                        && stringToDouble(map.get("ua")) < 235.4) {
                    map.put("countHg", 1);
                } else {
                    map.put("countHg", 0);
                }
                
                // 可以移除ua的数据
                map.remove("ua");
                resutlList.add(map);
            }
        }
        
        return resutlList;
    }

    /**
     * 对新的数据 计算占比
     * 
     * @param dataList
     * @return
     */
    public static List<Object> handleData(List<Map<String, Object>> dataList) {
        
        List<Object> list = new ArrayList<Object>();
        
        for (int i = 0; i < dataList.size(); i++) {

            double countSum = stringToDouble(dataList.get(i).get(
                    "countSum"));

            double countHgUa = stringToDouble(dataList.get(i).get(
                    "countHg"));
            list.add(countHgUa / countSum * 100);
        }
        
        return list;
    }
    
    /**
     * Object转换double
     * 
     * @param dataString
     * @return
     */
    private static double stringToDouble(Object dataString) {

        double dataDouble = 0;

        if (null == dataString || "".equals(dataString)) {

            dataDouble = 0;
        } else {

            dataDouble = Double.valueOf(dataString.toString());
        }
        return dataDouble;
    }
}

 

Answer 2

除了遍历，想不出来更好的办法。

Answer 3

这个好像是所有时间段之内的占比了，不是在同一时间内的。而且，用的jdk1.6 的，不能更换1.8的

Answer 4

回复
自己遍历一下map, 根据时间进行统计个数

Answer 5

public class TestListMap {
        
    public static void main(String[] args) {
        
        // 初始化集合
        List<Map<String, String>> list = init();
        
        double min = 198;
        double max = 235.4;
        System.out.printf("范围 %s ~ %s 占比为: %s", min, max, getUACount(list, min, max) * 1.0 / list.size());
    }
    
    public static int getUACount(List<Map<String, String>> list, double min, double max) {
        return list.stream()
                   .filter((map) -> {
                        double ua = Double.parseDouble(map.get("ua"));
                        return min <= ua && ua <= max;            
                    })                 //过滤出符合条件的
                   .mapToInt(map -> 1) //每一个元素,计数加1
                   .sum();             //统计个数
    }
}

代码使用了JDK 8的Lambda表达式, 所以最低版本为JDK 1.8

 

测试结果如下图: