比较 Java 中的地图项列表

Question

我有一个功能，我需要检查两个列表中的数据是否匹配。 该列表是Map <String, Object> 类型的链表。我应该如何迭代以最有效的方式比较列表中的每个项目？

现在我正在尝试做这样的事情：

public boolean compare(List<Map<String, Object>> A,
            List<Map<String, Object>> B) {
        //Code for iteration 
        boolean result = false;
        if(A.size() == B.size()) {    
            int count = 0;
            for(Map<String, Object> a : A)
            {
                for(Map<String, Object> b : B)
                {
                    if (a.get('aID') == b.get('aID'))
                        count++;
                }
            }
            if(count == A.size()) {
                result = true;
            }
        }    
        else {
            //Data reconciliation failed :: Data size mismatch
        }
        return result;
    }

但这是一种低效的方法，因为 A 中的每个项目都与 B 中的每个项目进行比较。

有更好的方法吗？

Answer 1

这里是朋友... 在 Java8 Streams 中比较两个 Map 列表以识别具有多个过滤谓词的匹配和不匹配记录的最有效方法是：

List<Map<String,String>> unMatchedRecords = dbRecords.parallelStream().filter(searchData ->
                inputRecords.parallelStream().noneMatch( inputMap ->
                        searchData.entrySet().stream().noneMatch(value ->
                                inputMap.entrySet().stream().noneMatch(value1 ->
                                        (value1.getKey().equals(value.getKey()) &&
                                                value1.getValue().equals(value.getValue()))))
                )).collect(Collectors.toList());

注意：

如果上面使用的

这样得到的不匹配记录，可以很容易地从任何一个列表（即dbRecords或inputRecords）中减去以检索匹配结果，并且操作迅速。

干杯，

舒巴姆乔汉

Answer 2

您可以遍历列表一次并比较每个列表中的地图。这会将您的 Big-O 运行时间减半——假设地图的顺序正确（即通过 LinkedList）。

public boolean compare(List<Map<String, Object>> A, List<Map<String, Object>> B) {
    // check size first
    if (A.size() == B.size()) {
      // if the Maps are abstracted into a POJO you could implement Comparator on that POJO.  In the meantime you can sort manually
      // sort A
      Collections.sort(A, new Comparator<Map<String, String>>() {
        public int compare(final Map<String, String> o1, final Map<String, String> o2) {
            // optionally, you could use any method of sorting here... single field like an ID, multiple fields compared, sums, etc.
            return o1.get("field").compareTo(o2.get("field"));
        }
    });

      // sort B
      Collections.sort(B, new Comparator<Map<String, String>>() {
        public int compare(final Map<String, String> o1, final Map<String, String> o2) {
            return o1.get("field").compareTo(o2.get("field"));
        }
    });


        for (int i = 0; i < A.size(); i++) {
            // get map from A & B
            Map<String, Object> aMap = A.get(i);
            Map<String, Object> bMap = B.get(i);

            // check equality of Maps
            if (!aMap.equals(bMap)) {
                return false;
            }
        }
    } else {
        // Data reconciliation failed :: Data size mismatch
        return false;
    }

    // if we get here then all was good
    return true;
}