在下面的例子中，如果您注释掉Person类中equals或hashcode的覆盖，此代码将无法查找Tom的订单。使用哈希码的默认实现可能会导致哈希表查找失败。

下面是一个简化的代码，它按Person提取人们的订单。Person被用作哈希表中的键。

public class Person {
    String name;
    int age;
    String socialSecurityNumber;

    public Person(String name, int age, String socialSecurityNumber) {
        this.name = name;
        this.age = age;
        this.socialSecurityNumber = socialSecurityNumber;
    }

    @Override
    public boolean equals(Object p) {
        //Person is same if social security number is same

        if ((p instanceof Person) && this.socialSecurityNumber.equals(((Person) p).socialSecurityNumber)) {
            return true;
        } else {
            return false;
        }

    }

    @Override
    public int hashCode() {        //I am using a hashing function in String.java instead of writing my own.
        return socialSecurityNumber.hashCode();
    }
}


public class Order {
    String[]  items;

    public void insertOrder(String[]  items)
    {
        this.items=items;
    }

}



import java.util.Hashtable;

public class Main {

    public static void main(String[] args) {

       Person p1=new Person("Tom",32,"548-56-4412");
        Person p2=new Person("Jerry",60,"456-74-4125");
        Person p3=new Person("Sherry",38,"418-55-1235");

        Order order1=new Order();
        order1.insertOrder(new String[]{"mouse","car charger"});

        Order order2=new Order();
        order2.insertOrder(new String[]{"Multi vitamin"});

        Order order3=new Order();
        order3.insertOrder(new String[]{"handbag", "iPod"});

        Hashtable<Person,Order> hashtable=new Hashtable<Person,Order>();
        hashtable.put(p1,order1);
        hashtable.put(p2,order2);
        hashtable.put(p3,order3);

       //The line below will fail if Person class does not override hashCode()
       Order tomOrder= hashtable.get(new Person("Tom", 32, "548-56-4412"));
        for(String item:tomOrder.items)
        {
            System.out.println(item);
        }
    }
}

我正在研究解释“如果你只覆盖hashCode，那么当你调用myMap.put(first,someValue)时，它首先接受，计算它的hashCode并将其存储在给定的桶中。然后，当你调用myMap.put(first,someOtherValue)时，它应该根据Map文档将first替换为second，因为它们是相等的(根据我们的定义)。”：

我认为第二次添加myMap时应该是第二个对象比如myMap。put(second,someOtherValue)

Bah -“你必须在每个重写equals()的类中重写hashCode()。”

[出自Joshua Bloch的《Effective Java》?］

Isn't this the wrong way round? Overriding hashCode likely implies you're writing a hash-key class, but overriding equals certainly does not. There are many classes that are not used as hash-keys, but do want a logical-equality-testing method for some other reason. If you choose "equals" for it, you may then be mandated to write a hashCode implementation by overzealous application of this rule. All that achieves is adding untested code in the codebase, an evil waiting to trip someone up in the future. Also writing code you don't need is anti-agile. It's just wrong (and an ide generated one will probably be incompatible with your hand-crafted equals).

他们肯定应该在被写来用作键的对象上强制设置一个接口吗?无论如何，Object永远不应该提供默认的hashCode()和equals() imho。它可能鼓励了许多破碎的散列集合。

但无论如何，我认为“规则”是前后颠倒的。与此同时，我将继续避免使用“等号”进行相等性测试方法:-(

恕我冒昧，这是根据规则说的-如果两个对象相等，那么它们应该具有相同的哈希值，即相等的对象应该产生相同的哈希值。

如上所述，Object is ==中的默认equals()对地址进行比较，hashCode()返回整数形式的地址(对实际地址进行哈希)，这对于不同的Object来说也是不同的。

如果你需要在基于哈希的集合中使用自定义对象，你需要覆盖equals()和hashCode()，例如如果我想维护员工对象的HashSet，如果我不使用更强的hashCode和equals，我可能最终会覆盖两个不同的员工对象，这发生在我使用年龄作为hashCode()时，但是我应该使用唯一的值，可以是员工ID。

加上@Lombo的答案

什么时候需要重写equals() ?

Object的equals()的默认实现是

public boolean equals(Object obj) {
        return (this == obj);
}

这意味着两个对象将被认为是相等的，只有当他们有相同的内存地址，这将是真的，只有当你是 比较对象本身。

但是，如果两个对象对一个对象具有相同的值，则可能认为它们是相同的 或更多的属性(参考@Lombo的回答中给出的例子)。

所以在这些情况下，你会重写equals()你会给出你自己的相等条件。

我已经成功地实现了equals()，它工作得很好。那么为什么他们要求重写hashCode()呢?

好。只要不在用户定义的类上使用基于“Hash”的集合，就没问题。 但是在将来的某个时候，你可能想要使用HashMap或HashSet，如果你没有覆盖和“正确实现”hashCode()，这些基于Hash的集合将无法正常工作。

只覆盖等于(除了@Lombo的答案)

myMap.put(first,someValue)
myMap.contains(second); --> But it should be the same since the key are the same.But returns false!!! How?

首先，HashMap检查second的hashCode是否与First相同。 只有当值相同时，它才会继续检查同一桶中的相等性。

但这里这两个对象的hashCode是不同的(因为它们具有不同的内存地址-与默认实现不同)。 因此，它甚至不会关心是否相等。

如果在重写的equals()方法中有断点，那么如果它们有不同的hashcode，它就不会介入。 contains()检查hashCode()，只有当它们相同时才调用equals()方法。

为什么我们不能让HashMap检查所有桶是否相等呢?所以我没有必要重写hashCode() !!

那么你就错过了基于哈希的集合的要点。 考虑以下几点:

Your hashCode() implementation : intObject%9.

以下是以桶的形式存储的密钥。

Bucket 1 : 1,10,19,... (in thousands)
Bucket 2 : 2,20,29...
Bucket 3 : 3,21,30,...
...

假设，您想知道映射是否包含键10。 你想把所有的桶都搜一遍吗?或“是否只搜索一个桶?”

根据hashCode，可以确定如果存在10，则它必须存在于Bucket 1中。 所以只有桶1会被搜索!!

简单地说，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方法