如何加快数据处理效率

Question

问题：需要对数据库查询出来的数据进行二次处理，现在的处理速度太慢了，优化下列代码
业务逻辑：数据库查询到房屋数据，然后需要对房屋数据进行统计，统计的字段如模拟数据库查询那一样，然后需要统计主房面积和辅房面积，房屋户数(/户数就是多少条数据)，人口数(人口数为房屋人员数量)，需要对这些字段的字符串进行拆分处理
代码如下：

    private static String[] strings = new String[]{"话","西","器"};    
     // 模拟数据库查询一页数据
    private static List<Map<String,Object>> tt(){
        List<Map<String,Object>> list = new ArrayList<>();
        Map<String,Object> map = null;
        Random random = new Random();
        for (int i = 0; i < 1000; i++) {
            StringBuilder stringBuilder = new StringBuilder();
            for (int j = 0; j <2; j++) {
                int s  = random.nextInt(2);
                stringBuilder.append(strings[s]);
            }
            map = new HashMap<>();
            map.put("JD",stringBuilder); // 所属地区
            map.put("MJ",205.5656); // 占地面积
            map.put("FWZDMJ","68.560@@62.3@@23.555555@@28.3"); // 房屋面积  主房面积@@辅@@辅......
            map.put("HJRKXM","张三@@李四@@王麻子@@王五"); // 房屋人员  张三@@李四@@王麻子@@王五....
            list.add(map);
        }
        return list;
    }
    
    
    public static void main(String[] args) {
        // 模拟service层进行数据处理
        List<Map<String, Object>> dataList = new ArrayList<>();
        List<Map<String, Object>> tt = tt();
        for (int i = 0; i <17 ; i++) {
            dataList = forPageData(dataList,tt);
        }
        System.out.println(dataList.size());
    }
    

    // service层处理当前页的数据
    private static List<Map<String, Object>>  forPageData(List<Map<String, Object>> dataList, List<Map<String, Object>> pageData) {
        List<Map<String, Object>> tempList = new ArrayList<>();
        boolean temp = false; // 是否有新的地区
        for (Map<String, Object> map : pageData) {
            // 判断是否第一次进来
            if (dataList.size() > 0) {
                // 循环处理过的数据，往里面新增数据
                for (Map<String, Object> objectMap : dataList) {
                    if (contains(dataList,map.get("JD") != null ? map.get("JD").toString() : map.get("CM").toString())) {
                        // 对当前地区的数据进行修改
                        addNfData(objectMap, map);
                    }else {
                        temp = true;
                        break;
                    }
                }
                if (temp){
                    // 添加新地区的数据
                    temp = false;
                    tempList.addAll(dataList);
                    dataList = new ArrayList<>();
                    dataList.add(addNfData(new HashMap<>(), map));
                }
            } else {
                // 第一次进入
                dataList.add(addNfData(new HashMap<>(), map));
            }
        }
        // 将最后一次的数据复制到tempList并返回
        tempList.addAll(dataList);
        return tempList;
    }

    // 判断数组中是否存在相同map
    private static boolean contains(List<Map<String,Object>> mapList,String s) {
        for (Map<String, Object> map : mapList) {
            if (map.containsKey("xzq")){
                if (map.get("xzq").toString().equals(s)){
                    return true;
                }
            }
        }
        return false;
    }

private static Map<String, Object> addNfData(Map<String, Object> map, Map<String, Object> cmNfsj) {
        // 初始化
        BigDecimal qzfwmj = new BigDecimal("0");
        BigDecimal fwmj = new BigDecimal("0");
        BigDecimal zfmj = new BigDecimal("0");
        BigDecimal aidedFwmj = new BigDecimal("0");
        int rks = 0;
        int hs = 0;

        // 存在则赋值
        if (!map.containsKey("xzq")) {
            map.put("xzq", cmNfsj.get("JD") != null ? cmNfsj.get("JD") : cmNfsj.get("CM"));
        } else {
            qzfwmj = new BigDecimal(map.get("qzfwmj").toString());
            fwmj = new BigDecimal(map.get("fwmj").toString());
            zfmj = new BigDecimal(map.get("zfmj").toString());
            aidedFwmj = new BigDecimal(map.get("aidedFwmj").toString());
            rks = Integer.parseInt(map.get("rks").toString());
            hs = Integer.parseInt(map.get("hs").toString());
        }

        // 值计算
        BigDecimal yjxmztz = new BigDecimal(cmNfsj.get("MJ").toString());
        qzfwmj = qzfwmj.add(yjxmztz);
        String fwzdmj = (String) cmNfsj.get("FWZDMJ");
        if (StringUtils.isNotEmpty(fwzdmj)) {
            fwmj = fwmj.add(computeMj(fwzdmj, false));
            aidedFwmj = aidedFwmj.add(computeMj(fwzdmj, true));
            zfmj = zfmj.add(new BigDecimal(fwzdmj.split("@@")[0]));
        }
        String hjrkxm = (String) cmNfsj.get("HJRKXM");
        if (StringUtils.isNotEmpty(hjrkxm)) {
            rks = rks + hjrkxm.split("@@").length;
        }

        // 赋回map
        map.put("qzfwmj", qzfwmj.setScale(4, BigDecimal.ROUND_HALF_UP));
        map.put("fwmj", fwmj.setScale(4, BigDecimal.ROUND_HALF_UP));
        map.put("zfmj", zfmj.setScale(4, BigDecimal.ROUND_HALF_UP));
        map.put("rks", rks);
        map.put("hs", hs + 1);
        map.put("aidedFwmj", aidedFwmj);

        return map;

    }

```

Answer 1

没细看，但是循环，判断太多。 可以，以stream流的方式优化，应该会好很多