根据元素规则列表筛选元素

漂亮的代码片

代码片.

import java.util.*;
import java.util.stream.Stream;

public class Test04 {
    public static void main(String[] args) {
        //元素规则集合[{max_count:10},{fh_count:2},{x_size:21},{x_count:2}]
        List<Map<String,String>> rules = new ArrayList<>();
        Map<String,String> map1 = new HashMap<>();
        map1.put("max_count","10");
        map1.put("fh_count","2");
        map1.put("x_size","21");
        map1.put("x_count","2");
        rules.add(map1);
        //元素集合
        List<Map<String,String>> elements = new ArrayList<>();
        elements.add(new HashMap<>());//模拟元素集合

        List<Map<String,String>> resultList = new ArrayList<>();//返回的元素结果集
        int tempFhCount = 0;//用来计数的分行元素个数
        int tempZhCount = 0;//用来计数的总行元素个数
        int tempXCount = 0;//用来计数的x_size元素个数

        for (Map<String, String> element : elements) {
            //筛选元素有效期，如果不满足则直接continue;
            //筛选元素生效地区号，如果不满足则直接continue;
            //筛选元素客群，如果不满足则直接continue;

            //程序走到这代表元素有效期、生效地区号、客群筛选均已满足
            if(rules.isEmpty()){
                //如果组件规则列表为空代表不需要别的条件进行筛选了，所以直接将元素添加到返回结果集中
                resultList.add(element);
            }

            //规则非空需要按照规则筛选元素
            if(!rules.isEmpty()){
                Optional<Map<String, String>> maxOptional = rules.stream().filter(x -> StringUtils.isNotBlank(x.get("max_count")) && !"0".equals(x.get("max_count"))).findAny();
                boolean maxFlag = maxOptional.isPresent();//是否有最大个数限制
                int maxCount = maxFlag ? Integer.parseInt(maxOptional.get().get("max_count")) : 0;//最大返回个数

                //有返回个数要求，但返回元素集合已满足个数要求
                if(maxFlag && resultList.size() >= maxCount){
                    continue;
                }

                Optional<Map<String, String>> fhOptional = rules.stream().filter(x -> StringUtils.isNotBlank(x.get("fh_count")) && !"0".equals(x.get("fh_count"))).findAny();
                boolean fhFlag = fhOptional.isPresent();//是否要求返回分行元素
                int fhCount = fhFlag ? Integer.parseInt(fhOptional.get().get("fh_count")) : 0;//分行个数

                String elementAreaCode = element.get("elementAreaCode");//维护机构，8888代表总行

                //分行元素，规则中没有分行个数要求（即不返回分行元素）
                if(!"8888".equals(elementAreaCode) && !fhFlag){
                    continue;
                }

                //分行元素，规则中有分行个数要求，但是返回分行元素已满足个数要求
                if(!"8888".equals(elementAreaCode) && fhFlag && (tempFhCount >= fhCount)){
                    continue;
                }

                //maxCount可能比fhCount大，可能相等，可能maxCount没有值但是fhCount有值，负数代表不限制总行个数，正数代表限制总行个数（0代表不需要返回总行数据）
                int zhCount = (maxCount - fhCount) == 0 ? 0 : (maxCount - fhCount);

                //总行元素，规则中没有总行个数要求(同时维护了fh_count和max_count,max_count减去fh_count等于0代表不需要返回总行元素)
                if("8888".equals(elementAreaCode) && (zhCount == 0)){
                    continue;
                }

                //总行元素，规则中有总行个数要求(同时维护了fh_count和max_count,max_count减去fh_count就是要求返回总行元素的个数)，但是返回总行元素已满足个数要求
                if("8888".equals(elementAreaCode) && (zhCount > 0) && (tempZhCount >= zhCount)){
                    continue;
                }

                Optional<Map<String, String>> xSizeOptional = rules.stream().filter(x -> StringUtils.isNotBlank(x.get("x_size"))).findAny();
                boolean xFlag = xSizeOptional.isPresent();//是否有x_size
                String xSize = xFlag ? xSizeOptional.get().get("x_size") : "0";
                Optional<Map<String, String>> nSizeOptional = rules.stream().filter(x -> StringUtils.isNotBlank(x.get("n_size"))).findAny();
                boolean nFlag = nSizeOptional.isPresent();//是否有n_size
                String nSize = nFlag ? nSizeOptional.get().get("n_size") : "0";
                Optional<Map<String, String>> xCountOptional = rules.stream().filter(x -> StringUtils.isNotBlank(x.get("x_count"))).findAny();
                int xCount = xCountOptional.isPresent() ? Integer.parseInt(xSizeOptional.get().get("x_count")) : 0;
                String picSize = element.get("E143");//图片尺寸

                //规则有图片尺寸要求，但是元素没有图片尺寸属性
                if(StringUtils.isBlank(picSize) && (xFlag || nFlag)){
                    continue;
                }

                //规则中有图片尺寸要求，但是元素图片尺寸属性不满足要求
                if(StringUtils.isNotBlank(picSize) && (!picSize.equals(xSize) && !picSize.equals(nSize))){
                    continue;
                }

                //规则中有图片尺寸要求，并且元素图片尺寸满足x_size，但是x_count已满
                if(StringUtils.isNotBlank(picSize) && picSize.equals(xSize) && (tempXCount >= xCount)){
                    continue;
                }

                //程序走到这就说明这个元素满足规则筛选条件了(前面已经将所有不满足的情况都continue了)，剩下的就看将该元素算在哪个里面了是fh_count、x_count、还是(max_count减fh_count)里面了
                resultList.add(element);

                //规则中有分行个数限制（需要分行元素），并且有x_size或者n_size（瓷片组件），并且元素图片尺寸与n_size相同，则tempFhCount+1，瓷片组件中n内分行元素个数
                if(fhFlag && (xFlag || nFlag) && picSize.equals(nSize) && !"8888".equals(elementAreaCode)){
                    tempFhCount++;
                    continue;
                }

                //规则中max_count比fh_count大（需要总行元素），并且有x_size或者n_size（瓷片组件），并且元素图片尺寸与n_size相同，则tempZhCount+1，瓷片组件中n内总行元素个数
                if((xFlag || nFlag) && picSize.equals(nSize) && "8888".equals(elementAreaCode)){
                    tempZhCount++;
                    continue;
                }

                //规则中有x_size或者n_size（瓷片组件），并且元素图片尺寸与x_size相同，则tempXCount+1
                if((xFlag || nFlag) && picSize.equals(xSize)){
                    tempXCount++;
                    continue;
                }

                //非瓷片组件，不用判断图片尺寸了，分行元素则tempFhCount++
                if(!"8888".equals(elementAreaCode)){
                    tempFhCount++;
                    continue;
                }

                //非瓷片组件，不用判断图片尺寸了，总行元素则tempZhCount++
                if("8888".equals(elementAreaCode)){
                    tempZhCount++;
                    continue;
                }

            }

        }

    }
}