如何修复允许重复的HashSet？

Question

I'm using a java.util.Set interface with a java.util.HashSet implementation and storing it in a Map.

I add an object to a Set then retrieve the Set object again and am able to add another object that is equal to the first.

When adding the seemingly equal objects, Set.add returns true and two equal objects are stored in a HashSet. How is this possible and what can I do to fix this apparent breakage of the Set contract?

I'm using Java 12 via IntelliJ IDEA 2018.3.6 and have checked my java.lang.Object.hashCode implementation for the class of the two objects I add to the Set, with both returning the same hash code. I've also checked the java.lang.Objects.equals implementation and it returns true when the method is used to check their equality. Both objects are wrapped in another object, Entity, but that only forwards the objects' hashCode and equals implementations.

class Model {

    ...

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (!(obj instanceof Offer)) {
            return false;
        }

        Offer offer = (Offer) obj;
        return Objects.equals(id, offer.id)
            && Objects.equals(name, offer.name)
            ;
    }

    @Override
    public int hashCode() {
        int result = 1;
        result = 31 * result + Objects.hashCode(id);
        result = 31 * result + Objects.hashCode(name);
        return result;
    }

    ...

}

class Store {

    ...

    private static class Entry {
        Object value;

        Entry(Object value) {
            this.value = value;
        }

        Object getValue() {
            return value;
        }

        @Override
        public boolean equals(Object obj) {
            return Objects.equals(value, obj);
        }

        @Override
        public int hashCode() {
            return value.hashCode();
        }

        @Override
        public String toString() {
            return "Entry[value = " + value + "]";
        }
    }

    ...

    private Map<Class<?>, Set<Entry>> data;

    ...

    private Set<Entry> get(Class<?> type) {
        return data.getOrDefault(type, new HashSet<>());
    }

    @Override
    public void persist(Object obj) {
        Entry entry = new Entry(obj);
        Set<Entry> objects = get(obj.getClass());
        if (objects == null) {
            objects = new HashSet<>();
        }
        if (!objects.add(entry)) {
            throw new ObjectExistsException
                ("Object already exists: " + obj);
        }
        data.put(obj.getClass(), objects);
    }

    ...

}

When obj1 and obj2 of type Model are equal and objects already contains obj1 wrapped in an Entry object, I expect obj2 not to be added to objects when obj2 is wrapped in entry and for objects.add(entry) to return false then an ObjectExistsException to be thrown.

However, what actually is happening is objects.add(entry) returns true and obj2 wrapped in entity is being added to objects .

Answer 1

    @Override
    public boolean equals(Object obj) {
        return Objects.equals(value, obj);
    }

This isn't a correct implementation of Entry.equals . This potentially compares an Entry with the value held by the current entry. (Like comparing a letter with an envelope).

Make your equals method check that obj is an Entry , and get its value, and check equality to that.

Answer 2

You were right @Andy Turner, but it was @Andreas that pointed me in the right direction. I thought I would be lazy and not write a full equals method implementation, but it cost me. It should have been like this:

private static class Entry {
    ...
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (!(obj instanceof Entry)) {
            return false;
        }

        Entry entry = (Entry) obj;
        return Objects.equals(getValue(), entry.getValue());
    }
    ...
}

Thank you both.