Question

我有两个哈希图A＆amp; B型。我想同时比较两个地图的值，保持B＆＃39的值作为比较的参考，如果找到值等于否则增加correctValue计数器，否则增加correctValue计数器。

例如，

    int correctValuesCounter = 0;
    int incorrectValuesCounter = 0;

    Map<Int, Double> A = new HashMap<Int, Double>();
    Map<Int, Double> B = new HashMap<Int, Double>();

    A.put(1, 0.0);
    A.put(2, 1.0);
    A.put(3, 0.0);
    A.put(4, 0.0);
    A.put(5, 1.0);
    A.put(6, 1.0);


    B.put(1, 0.0);
    B.put(2, 1.0);
    B.put(3, 0.0);
    B.put(4, 0.0);
    B.put(5, 1.0);
    B.put(6, 1.0);

现在，这些地图值相等，因此，correctValuesCounter应为6，且ignoreValuesCounter应为0.同样，如果A.put（3,0.0）更改为A.put（3,1.0）和B（2， 1.0）更改为B（2,0.0）然后correctValuesCounter将变为4并且incorrectValuesCounter将变为2，依此类推。

到目前为止我所拥有的并没有给我预期的结果，所以有人可以指导我朝正确的方向发展吗？

public void checkEqualValues(Map<Integer, Double> A, Map<Integer, Double> B)
    {       
        for(double value : A.values())
        {
            if(A.size() == B.size())
            {
                if(B.values().contains(value))
                {
                    correctValuesCounter++;
                }
                else
                    incorrectValuesCounter++;
            }
            else
                System.out.println("Unequal list");
        }

        System.out.println("correctValuesCounter: "+correctValuesCounter);
        System.out.println("incorrectValuesCounter:"+incorrectValuesCounter);
    }

但是，对于所有排列和组合，这都返回true（即correctValuesCounter: 6）（即使我将任一列表中的值更改为彼此不相等）。有人可以帮忙吗？

Answer 1

您正在检查B Map 是否包含 A.value()

您必须获得a.getKey()并将其与b.get(a.getKey());

中的值进行比较

这样的事情：

for (Map.Entry<Int, Double> aEntry : A.entrySet())
    Int key = aEntry.getKey();
    double aVal = aEntry.getValue();
    double bVal = B.get(key);

    if (aVal == bVal) {
        correctValuesCounter++;
    } else {
        incorrectValuesCounter++;
    }
}

Answer 2

您并未真正检查B地图是否包含正确位置的值，您只是检查它是否包含所有。所以你想要做一些事情，比如从A获取键的迭代器，遍历它并确保B中的相同键包含相同的值。

Answer 3

比较HashMaps的逻辑是不正确的。您基本上检查的是，在B中存在的所有值中，是否存在特定值？这不考虑与值相关联的键。如果我理解正确，您实际需要的代码如下：

public void checkEqualValues(HashMap<Integer, Double> A, HashMap<Integer, Double> B) {
    if (A.size() == B.size()) {
        for (int key : A.keySet()) {
            if (B.containsKey(key)) {
                if (Objects.equals(A.get(key), B.get(key))) {
                    correctValuesCounter++;
                }
            } else {
                incorrectValuesCounter++;
            }
        }
        System.out.println("correctValuesCounter: " + correctValuesCounter);
        System.out.println("incorrectValuesCounter:" + incorrectValuesCounter);
    } else {
       System.out.println("HashMaps are of different sizes");
    }
}

Answer 4

您正在使用地图来键入您的值。您需要检查A.get(value) == B.get(value)。不是一个值包含在另一个中。

此外，我想你不仅要检查`A.size（）== B.size（）＆＃39;但在继续之前，这些值是一样的吗？否则，在尝试将null与整数进行比较时会出错。

 public void checkEqualValues(HashMap<Integer, Double> A, HashMap<Integer, Double> B) {
        int correctValuesCounter = 0, incorrectValuesCounter = 0;
        if (A.values().containsAll(B.values()) && B.values().containsAll(A.values()) ) {
            for (int key : A.keySet()) {
                if (A.get(key).equals(B.get(key))) {
                    correctValuesCounter++;
                } else {
                    incorrectValuesCounter++;
                }
            }
            System.out.println("correctValuesCounter: " + correctValuesCounter);
            System.out.println("incorrectValuesCounter:" + incorrectValuesCounter);
        } else {
            if(A.size()!=B.size())
                System.out.println("HashMaps are of different sizes");
            System.out.println("HashMap's keys are different.");
        }
    }

编辑：假设A.get(key)不能为空;

Answer 5

您正在将您的值与contains进行比较。

这实际上意味着当B中A中的值包含时，您正在递增计数器，而不是相同的密钥！

使用基于键集的迭代来比较值，如下所示：

if (A.size() != B.size()) {
    System.out.println("Different sizes :(");
}
for (Integer key: B.keySet()) {
    if (A.get(key) != null && A.get(key).equals(B.get(key))) {
        correctValuesCounter++;
    }
}
System.out.printf("Correct values counter: %d%n", correctValuesCounter);

<强>输出

Correct values counter: 6

比较两个hashamps和增量计数器中的值

5 个答案: