Joshua Bloch在Effective Java上说

必须在重写equals()的每个类中重写hashCode()。如果不这样做，将违反Object.hashCode()的一般约定，这将阻止您的类与所有基于哈希的集合(包括HashMap、HashSet和Hashtable)一起正常运行。

让我们通过一个例子来理解它，如果我们重写equals()而不重写hashCode()并尝试使用Map会发生什么。

假设我们有这样一个类，如果MyClass的两个对象的importantField相等(使用eclipse生成的hashCode()和equals())，则MyClass的两个对象相等

public class MyClass {
    private final String importantField;
    private final String anotherField;

    public MyClass(final String equalField, final String anotherField) {
        this.importantField = equalField;
        this.anotherField = anotherField;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result
                + ((importantField == null) ? 0 : importantField.hashCode());
        return result;
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final MyClass other = (MyClass) obj;
        if (importantField == null) {
            if (other.importantField != null)
                return false;
        } else if (!importantField.equals(other.importantField))
            return false;
        return true;
    }
}

想象一下你有这个

MyClass first = new MyClass("a","first");
MyClass second = new MyClass("a","second");

只覆盖等于

如果只有equals被覆盖，那么当你调用myMap.put(first,someValue)首先将哈希到某个桶，当你调用myMap.put(second,someOtherValue)它将哈希到其他一些桶(因为它们有不同的hashCode)。所以，尽管它们是相等的，因为它们不散列到同一个桶，映射无法意识到这一点，它们都留在映射中。

虽然如果重写hashCode()就没有必要重写equals()，但让我们看看在这种特殊情况下会发生什么:我们知道MyClass的两个对象是相等的，如果它们的importantField相等，但我们没有重写equals()。

只覆盖hashCode

如果你只覆盖hashCode，那么当你调用myMap.put(first,someValue)时，它首先接受，计算它的hashCode并将其存储在给定的bucket中。然后，当您调用myMap.put(second,someOtherValue)时，它应该根据Map文档将first替换为second，因为它们是相等的(根据业务需求)。

但问题是，equals没有被重新定义，所以当map哈希second并遍历bucket时，寻找是否有一个对象k，使得second.equals(k)为真，它不会找到任何对象，因为second.equals(first)将为假。

希望这是清楚的

如果重写equals()而不是hashcode()，则不会发现任何问题，除非您或其他人在HashSet等散列集合中使用该类类型。 在我之前的人已经清楚地解释了很多次文献理论，我只是在这里提供一个非常简单的例子。

考虑一个类，它的equals()需要表示自定义的东西:-

    public class Rishav {

        private String rshv;

        public Rishav(String rshv) {
            this.rshv = rshv;
        }

        /**
        * @return the rshv
        */
        public String getRshv() {
            return rshv;
        }

        /**
        * @param rshv the rshv to set
        */
        public void setRshv(String rshv) {
            this.rshv = rshv;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj instanceof Rishav) {
                obj = (Rishav) obj;
                if (this.rshv.equals(((Rishav) obj).getRshv())) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }

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

    }

现在考虑这个主类:-

    import java.util.HashSet;
    import java.util.Set;

    public class TestRishav {

        public static void main(String[] args) {
            Rishav rA = new Rishav("rishav");
            Rishav rB = new Rishav("rishav");
            System.out.println(rA.equals(rB));
            System.out.println("-----------------------------------");

            Set<Rishav> hashed = new HashSet<>();
            hashed.add(rA);
            System.out.println(hashed.contains(rB));
            System.out.println("-----------------------------------");

            hashed.add(rB);
            System.out.println(hashed.size());
        }

    }

这将产生以下输出:-

    true
    -----------------------------------
    true
    -----------------------------------
    1

我对结果很满意。但是如果我没有覆盖hashCode()，它将导致噩梦，因为具有相同成员内容的Rishav对象将不再被视为唯一的hashCode将是不同的，因为由默认行为生成，这里将是输出:-

    true
    -----------------------------------
    false
    -----------------------------------
    2

假设你有一个类(A)，它聚合了另外两个类(B) (C)，你需要在哈希表中存储类(A)的实例。默认实现只允许区分实例，但不允许通过(B)和(C)。因此A的两个实例可以相等，但默认不允许您以正确的方式比较它们。

它在使用值对象时很有用。以下摘自Portland Pattern Repository:

Examples of value objects are things like numbers, dates, monies and strings. Usually, they are small objects which are used quite widely. Their identity is based on their state rather than on their object identity. This way, you can have multiple copies of the same conceptual value object. So I can have multiple copies of an object that represents the date 16 Jan 1998. Any of these copies will be equal to each other. For a small object such as this, it is often easier to create new ones and move them around rather than rely on a single object to represent the date. A value object should always override .equals() in Java (or = in Smalltalk). (Remember to override .hashCode() as well.)

简单地说，Object中的equals-方法检查引用是否相等，当属性相等时，类的两个实例在语义上仍然相等。例如，当将对象放入使用等号和hashcode(如HashMap和Set)的容器中时，这很重要。假设我们有这样一个类:

public class Foo {
    String id;
    String whatevs;

    Foo(String id, String whatevs) {
        this.id = id;
        this.whatevs = whatevs;
    }
}

我们创建了两个具有相同id的实例:

Foo a = new Foo("id", "something");
Foo b = new Foo("id", "something else");

如果不重写等号，我们将得到:

A.equals (b)为假，因为它们是两个不同的实例 a.equals(a)为真，因为它是同一个实例 b.equals(b)为真，因为它是同一个实例

正确吗?也许吧，如果这是你想要的。但假设我们希望具有相同id的对象是相同的对象，不管它是否是两个不同的实例。我们重写等号(和hashcode):

public class Foo {
    String id;
    String whatevs;

    Foo(String id, String whatevs) {
        this.id = id;
        this.whatevs = whatevs;
    }

    @Override
    public boolean equals(Object other) {
        if (other instanceof Foo) {
            return ((Foo)other).id.equals(this.id);   
        }
    }

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

至于实现equals和hashcode，我建议使用Guava的helper方法

因为如果你不重写它们，你将使用Object中的默认实现。

考虑到实例相等和hascode值通常需要了解组成对象的内容，它们通常需要在类中重新定义，以具有任何有形的意义。