Map / Set对象图的奇怪equals（）结果

Question

Investigating a special case where some objects didn't equal as they should and came to this simple test case that simplifies my issue.

When running this with JUnit in Eclipse with jdk8u152 the last assertEquals fails, can anyone explain why?

It's something with Set/HashSet because if I change as,bs to be ArrayList's instead the final assertEquals goes through.

@Test
public void test()
{
    String list = "list";
    String object = "object";
    String value = "value";

    Map<String, Object> a = new HashMap<>();
    Map<String, Object> b = new HashMap<>();

    assertEquals(a, b);

    Set<Object> as = new HashSet<>();
    Set<Object> bs = new HashSet<>();

    a.put(list, as);
    b.put(list, bs);

    assertEquals(a, b);

    Map<String, Object> ao = new HashMap<>();
    as.add(ao);
    Map<String, Object> bo = new HashMap<>();
    bs.add(bo);

    assertEquals(a, b);

    ao.put(object, value);
    bo.put(object, value);

    assertEquals(a, b);
}

Answer 1

You're mutating the elements of the sets. That leads to unspecified behaviour.

From the JavaDoc :

Great care must be exercised if mutable objects are used as set elements. The behavior of a set is not specified if the value of an object is changed in a manner that affects equals comparisons while the object is an element in the set.

Answer 2

You are adding ao and bo HashMap s to the HashSet s as and bs .

Later you mutate ao and bo by putting a new entry in each of them.

This means that the hashCode that was used to place ao in as is no longer the current hashCode of ao , and the hashCode that was used to place bo in bs is no longer the current hashCode of bo .

As a result, AbstractSet 's equals cannot locate the element of one Set in the other Set , so it concludes that as is not equal to bs . As a result a is not equal to b .

Here's the implementation of AbstractSet 's equals . You can see that it uses containsAll , which in turns calls contains() , which relies on the hashCode of the searched element. Since that hashCode has changed after the element was added to the Set , contains() doesn't find the element.

public boolean equals(Object o) {
    if (o == this)
        return true;

    if (!(o instanceof Set))
        return false;
    Collection<?> c = (Collection<?>) o;
    if (c.size() != size())
        return false;
    try {
        return containsAll(c);
    } catch (ClassCastException unused)   {
        return false;
    } catch (NullPointerException unused) {
        return false;
    }
}

If you mutate an element of a HashSet in a way that affects the result of equals or hashCode , you must remove the element from the HashSet prior to the update and add it again after the update.

Adding the following remove and add calls will cause a to be equal to b in the end:

....
assertEquals(a, b);

bs.remove (bo); // added
as.remove (ao); // added

ao.put(object, value);
bo.put(object, value);

as.add (ao); // added
bs.add (bo); // added

assertEquals(a, b);

Answer 3

That is because of the hascode implementation of HashMap which is basically x-or of key and value. If key or value is null then hascode will be zero. Hence all empty hashmaps will have hashcode as zero.

/*hashcode of HashMap*/
    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

/*hashcode of object*/
    public static int hashCode(Object o) {
        return o != null ? o.hashCode() : 0;
    }

Upon adding key value pairs the hashcode value changes.