Java 两个 List<Map<String,Obj>> 怎么找出不同的数据呢？ 求指点！！！

Question

现在需求是： 有两个
List<Map<String,Object>> list1
List<Map<String,Object>> list2

list1 中的数据会很多; 例如: list1 有100条
list2 中的数据肯定不会比list1多; 例如: list2 有10条
这两条没有上下对应的关系 list1数据和list2顺序也不一样。
暂且把这两个list想象成记录的是用户信息的数据吧
其中list1中的100条数据和list2中的10条数据是一样的 这是期望的结果
但是 偶尔会出现list2中的10条中 其中一条对应不上list1中的100条其中的一条（有时候可能有多条对应不上） 比如 list2中的 王五的acctNo 不等于list1中的 王五acctNo 然后把这条数据给找出来！也就是把这个map找出来（有时候可能有多条，多个map可以返回List<Map>） 这就是需求。

需求变了··· 领导说name也可能不一样！ 我特么醉了··· 现在的情况就会是 name不一样, acctNo不一样，phone不一样，date不一样， 我的想法是 两个list先比较name 如果不一样那就存一条， acctNo不一样存一条，phone不一样存一条 date不一样存一条 (这些不相等的数据如果有多条那就是List<Map>)， 这个也符合需求 最终商量就是这么干， 这种情况怎么写呀？？？ 求指点！

给出测试数据：

分割线===================================

新的测试数据 更新于 2020-06-25  22:15

List<String> paramName = Arrays.asList("ORDERNO", "OSORDERID", "AMT", "TRANDATE");
        DataSelector.Result result = DataSelector.init(paramName)
                .addMain(list1())
                .addSub(list2())
                .select();
        System.out.println(JSON.toJSONString(result));

public static   List<Map<String,Object>> list1(){
    List<Map<String,Object>> list1=new ArrayList<>();

    Map<String,Object> mapA1=new HashMap();
    mapA1.put("ORDERNO","o20200611001");
    mapA1.put("OSORDERID","os20200611001");
    mapA1.put("AMT","1000");
    mapA1.put("TRANDATE","20200610");

    mapA1.put("TRXSERNO","seq20200611001");
    list1.add(mapA1);

    Map<String,Object> mapA2=new HashMap();
    mapA2.put("ORDERNO","o20200611002");
    mapA2.put("OSORDERID","os20200611002");
    mapA2.put("AMT","2000");
    mapA2.put("TRANDATE","shanxi");

    mapA2.put("PDATE","Thu Jun 11 00:00:00 CST 2020");
    list1.add(mapA2);

    Map<String,Object> mapA3=new HashMap();
    mapA3.put("ORDERNO","o20200611003");
    mapA3.put("OSORDERID","os20200611003");
    mapA3.put("AMT","3000");
    mapA3.put("TRANDATE","20200610");

    mapA3.put("TRXSERNO","seq20200611003");
    list1.add(mapA3);

    Map<String,Object> mapA4=new HashMap();
    mapA4.put("ORDERNO","o20200611001_01");
    mapA4.put("OSORDERID","os20200611001_01");
    mapA4.put("AMT","1200");

    mapA4.put("TRXSERNO","seq20200611001_01");
    list1.add(mapA4);

    Map<String,Object> mapA5=new HashMap();
    mapA5.put("ORDERNO","o20200611001_03");
    mapA5.put("OSORDERID","os20200611001_03");
    mapA5.put("AMT","3100");
    mapA5.put("TRANDATE","20200610");

    mapA5.put("TRXSERNO","seq20200611001_03");
    list1.add(mapA5);
    return  list1;
}

public static List<Map<String,Object>> list2(){
    List<Map<String,Object>> list2=new ArrayList<>();

    Map<String,Object> mapB3=new HashMap();
    mapB3.put("ORDERNO","o20200611001");
    mapB3.put("OSORDERID","os20200611001");
    mapB3.put("AMT","1000");
    mapB3.put("TRANDATE","20200610");

    mapB3.put("ACCOUNT_NO","DCCX000000001");
    list2.add(mapB3);

    Map<String,Object> mapB2=new HashMap();
    mapB2.put("ORDERNO","o20200611002");
    mapB2.put("OSORDERID","os20200611002");
    mapB2.put("AMT","1000");
    mapB2.put("TRANDATE","shanxi");

    mapB2.put("ACCOUNT_NO","DCCX003");
    list2.add(mapB2);
    return  list2;
}

两种方案执行结果如下：
方案1结果：
{
    "diffList":[
    ],
    "sameList":[
        {
            "ORDERNO":"o20200611001",
            "AMT":"1000",
            "ACCOUNT_NO":"DCCX000000001",
            "OSORDERID":"os20200611001",
            "TRANDATE":"20200610"
        },
        {
            "ORDERNO":"o20200611002",
            "AMT":"1000",
            "ACCOUNT_NO":"DCCX003",
            "OSORDERID":"os20200611002",
            "TRANDATE":"shanxi"
        }]
}

方案2执行结果
{
    "diffList":[
    ],
    "sameList":[
        {
            "ORDERNO":"o20200611001",
            "AMT":"1000",
            "ACCOUNT_NO":"DCCX000000001",
            "OSORDERID":"os20200611001",
            "TRANDATE":"20200610"
        },
        {
            "ORDERNO":"o20200611002",
            "AMT":"1000",
            "ACCOUNT_NO":"DCCX003",
            "OSORDERID":"os20200611002",
            "TRANDATE":"shanxi"
        }]
}


我期望的结果为：
{
    "diffList":[
        {
            "data":{
                "ORDERNO":"o20200611002",
                "AMT":"1000",
                "ACCOUNT_NO":"DCCX003",
                "OSORDERID":"os20200611002",
                "TRANDATE":"shanxi"
            },
            "paramNames":[
                 "AMT"
            ]
        }
    ],
    "sameList":[
        {
            "ORDERNO":"o20200611001",
            "AMT":"1000",
            "ACCOUNT_NO":"DCCX000000001",
            "OSORDERID":"os20200611001",
            "TRANDATE":"20200610"
        }
    ]
}

Answer 1

究极无敌最终版！！！

方案1版本代码（mapB2在diff中返回两次）：

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class DataSelector {

    private List<Map<String, Object>> mainList;
    private List<Map<String, Object>> subList;
    private List<String> paramNames;

    public static DataSelector init(List<String> paramNames) {
        DataSelector dataSelector = new DataSelector();
        dataSelector.paramNames = paramNames;
        return dataSelector;
    }

    public DataSelector addMain(List<Map<String, Object>> mainList) {
        this.mainList = mainList;
        return this;
    }

    public DataSelector addSub(List<Map<String, Object>> subList) {
        this.subList = subList;
        return this;
    }

    public Result select() {

        Result result = new Result();

        SelectCollectorImpl.Result mainResult = this.mainList.stream().collect(new SelectCollectorImpl(this.paramNames));

        Set<String> valueSet = mainResult.getValueSet();
        for (Map<String, Object> map : this.subList) {
            SelectCollectorImpl.Result subResult = SelectCollectorImpl.Result.init(map, this.paramNames);
            if (valueSet.contains(subResult.getFirstValue())) {
                result.addSame(map);
            }else {
                List<Map<String, Object>> relatedMapList = mainResult.getRelatedMapList();
                for (Map<String, Object> relatedMap : relatedMapList) {
                    List<String> diffParamNames = this.paramNames.stream().filter(paramName -> !map.get(paramName).equals(relatedMap.get(paramName))).collect(Collectors.toList());
                    if (diffParamNames.size() != this.paramNames.size()) {
                        result.addDiff(map, diffParamNames);
                    }
                }
            }
        }
        return result;
    }

    @Getter
    @Setter(value = AccessLevel.PRIVATE)
    @NoArgsConstructor(access = AccessLevel.PRIVATE)
    @ToString
    static class Result {
        private List<Map<String, Object>> sameList = new ArrayList<>();
        private List<Diff> diffList = new ArrayList<>();

        public Result addSame(Map<String, Object> map) {
            this.sameList.add(map);
            return this;
        }

        public Result addDiff(Map<String, Object> data, List<String> paramNames) {
            Diff diff = new Diff(data, paramNames);
            this.diffList.add(diff);
            return this;
        }

        @Getter
        @Setter(value = AccessLevel.PRIVATE)
        @AllArgsConstructor(access = AccessLevel.PRIVATE)
        @ToString
        static class Diff {
            private Map<String, Object> data;
            private List<String> paramNames;
        }
    }
}

@AllArgsConstructor
public class SelectCollectorImpl implements Collector<Map<String, Object>, SelectCollectorImpl.Result, SelectCollectorImpl.Result> {

    private List<String> keys;

    @Override
    public Supplier<Result> supplier() {
        return Result::new;
    }

    @Override
    public BiConsumer<Result, Map<String, Object>> accumulator() {
        return (result, map) -> result.addValue(map, this.keys);
    }

    @Override
    public BinaryOperator<Result> combiner() {
        return Result::merge;
    }

    @Override
    public Function<Result, Result> finisher() {
        return Function.identity();
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.IDENTITY_FINISH));
    }

    @Getter
    @Setter(value = AccessLevel.PRIVATE)
    static class Result {
        private Set<String> valueSet = new HashSet<>();
        private List<Map<String, Object>> relatedMapList = new ArrayList<>();

        public String getFirstValue() {
            return this.valueSet.stream().findFirst().get();
        }

        private Result addValue(Map<String, Object> map, List<String> keys) {
            addValue(this, map, keys);
            return this;
        }

        public static Result init(Map<String, Object> map, List<String> keys) {
            Result result = new Result();
            addValue(result, map, keys);
            return result;
        }

        private static void addValue(Result result, Map<String, Object> map, List<String> keys) {
            List<String> valueList = new ArrayList<>();
            Map<String, Object> matchMap = new HashMap<>();
            for (String key : keys) {
                Object value = map.get(key);
                if (value == null) continue;
                valueList.add(value.toString());
                matchMap.put(key, value);
            }

            String valueStr = valueList.stream().collect(Collectors.joining("-"));
            result.getValueSet().add(valueStr);

            result.getRelatedMapList().add(matchMap);
        }

        private Result merge(Result result) {
            this.getValueSet().addAll(result.getValueSet());
            this.getRelatedMapList().addAll(result.getRelatedMapList());
            return this;
        }
    }
}

方案2版本代码（mapB2返回一次）：

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class DataSelector {

    private List<Map<String, Object>> mainList;
    private List<Map<String, Object>> subList;
    private List<String> paramNames;

    public static DataSelector init(List<String> paramNames) {
        DataSelector dataSelector = new DataSelector();
        dataSelector.paramNames = paramNames;
        return dataSelector;
    }

    public DataSelector addMain(List<Map<String, Object>> mainList) {
        this.mainList = mainList;
        return this;
    }

    public DataSelector addSub(List<Map<String, Object>> subList) {
        this.subList = subList;
        return this;
    }

    public Result select() {

        Result result = new Result();

        SelectCollectorImpl.Result mainResult = this.mainList.stream().collect(new SelectCollectorImpl(this.paramNames));

        Set<String> valueSet = mainResult.getValueSet();
        Set<String> sameValueSet = new HashSet<>();
        for (Map<String, Object> map : this.subList) {
            SelectCollectorImpl.Result subResult = SelectCollectorImpl.Result.init(map, this.paramNames);
            String value = subResult.getFirstValue();
            if (valueSet.contains(value)) {
                result.addSame(map);
                sameValueSet.add(value);
            }else {
                Map<String, Map<String, Object>> originalMap = mainResult.getOriginalMap();
                for (Map.Entry<String, Map<String, Object>> entry : originalMap.entrySet()) {
                    if (sameValueSet.contains(entry.getKey())) continue;
                    List<String> diffParamNames = this.paramNames.stream().filter(paramName -> !map.get(paramName).equals(entry.getValue().get(paramName))).collect(Collectors.toList());
                    if (diffParamNames.size() != this.paramNames.size()) {
                        result.addDiff(map, diffParamNames);
                    }
                }
            }
        }
        return result;
    }

    @Getter
    @Setter(value = AccessLevel.PRIVATE)
    @NoArgsConstructor(access = AccessLevel.PRIVATE)
    @ToString
    static class Result {
        private List<Map<String, Object>> sameList = new ArrayList<>();
        private List<Diff> diffList = new ArrayList<>();

        public Result addSame(Map<String, Object> map) {
            this.sameList.add(map);
            return this;
        }

        public Result addDiff(Map<String, Object> data, List<String> paramNames) {
            Diff diff = new Diff(data, paramNames);
            this.diffList.add(diff);
            return this;
        }

        @Getter
        @Setter(value = AccessLevel.PRIVATE)
        @AllArgsConstructor(access = AccessLevel.PRIVATE)
        @ToString
        static class Diff {
            private Map<String, Object> data;
            private List<String> paramNames;
        }
    }
}

@AllArgsConstructor
public class SelectCollectorImpl implements Collector<Map<String, Object>, SelectCollectorImpl.Result, SelectCollectorImpl.Result> {

    private List<String> keys;

    @Override
    public Supplier<Result> supplier() {
        return Result::new;
    }

    @Override
    public BiConsumer<Result, Map<String, Object>> accumulator() {
        return (result, map) -> result.addValue(map, this.keys);
    }

    @Override
    public BinaryOperator<Result> combiner() {
        return Result::merge;
    }

    @Override
    public Function<Result, Result> finisher() {
        return Function.identity();
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.IDENTITY_FINISH));
    }

    @Getter
    @Setter(value = AccessLevel.PRIVATE)
    static class Result {
        private Set<String> valueSet = new HashSet<>();
        private Map<String, Map<String, Object>> originalMap = new HashMap<>();

        public String getFirstValue() {
            return this.valueSet.stream().findFirst().get();
        }

        private Result addValue(Map<String, Object> map, List<String> keys) {
            addValue(this, map, keys);
            return this;
        }

        public static Result init(Map<String, Object> map, List<String> keys) {
            Result result = new Result();
            addValue(result, map, keys);
            return result;
        }

        private static void addValue(Result result, Map<String, Object> map, List<String> keys) {
            List<String> valueList = new ArrayList<>();
            for (String key : keys) {
                Object value = map.get(key);
                if (value == null) continue;
                valueList.add(value.toString());
            }

            String valueStr = valueList.stream().collect(Collectors.joining("-"));
            result.getValueSet().add(valueStr);

            result.getOriginalMap().put(valueStr, map);
        }

        private Result merge(Result result) {
            this.getValueSet().addAll(result.getValueSet());
            this.getOriginalMap().putAll(result.getOriginalMap());
            return this;
        }
    }
}

---

究极最终版！！

我怕需求不清，所以还是建议题主试试我的代码

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class DataSelector {

    private List<Map<String, Object>> mainList;
    private List<Map<String, Object>> subList;
    private List<String> paramNames;

    public static DataSelector init(List<String> paramNames) {
        DataSelector dataSelector = new DataSelector();
        dataSelector.paramNames = paramNames;
        return dataSelector;
    }

    public DataSelector addMain(List<Map<String, Object>> mainList) {
        this.mainList = mainList;
        return this;
    }

    public DataSelector addSub(List<Map&