常见错误如下例所示。

public class Car {

    private String color;

    public Car(String color) {
        this.color = color;
    }

    public boolean equals(Object obj) {
        if(obj==null) return false;
        if (!(obj instanceof Car))
            return false;   
        if (obj == this)
            return true;
        return this.color.equals(((Car) obj).color);
    }

    public static void main(String[] args) {
        Car a1 = new Car("green");
        Car a2 = new Car("red");

        //hashMap stores Car type and its quantity
        HashMap<Car, Integer> m = new HashMap<Car, Integer>();
        m.put(a1, 10);
        m.put(a2, 20);
        System.out.println(m.get(new Car("green")));
    }
}

绿色的车没有找到

2. hashCode()引起的问题

该问题是由未覆盖的hashCode()方法引起的。equals()和hashCode()之间的契约是:

如果两个对象相等，那么它们必须具有相同的哈希码。 如果两个对象具有相同的哈希码，则它们可能相等，也可能不相等。 公共int hashCode(){ 返回this.color.hashCode (); ｝

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)将为假。

希望这是清楚的

在下面的例子中，如果您注释掉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()方法用于获取给定对象的唯一整数。这个整数用于确定桶的位置，当这个对象需要存储在一些HashTable, HashMap之类的数据结构时。默认情况下，Object的hashCode()方法返回存储Object的内存地址的整数表示形式。

对象的hashCode()方法用于将对象插入到HashTable、HashMap或HashSet中。更多关于哈希表的信息请参见Wikipedia.org。

要在map数据结构中插入任何条目，我们需要键和值。如果键和值都是用户定义的数据类型，则键的hashCode()将确定在内部将对象存储在何处。当还需要从映射中查找对象时，键的哈希码将确定在哪里搜索对象。

哈希码只在内部指向某个“区域”(或列表，桶等)。因为不同的键对象可能具有相同的哈希码，所以哈希码本身并不能保证找到正确的键。然后哈希表迭代该区域(具有相同哈希代码的所有键)，并使用键的equals()方法找到正确的键。一旦找到正确的键，就会返回为该键存储的对象。

因此，正如我们所看到的，hashCode()和equals()方法的组合在哈希表中存储和查找对象时使用。

注:

总是使用对象的相同属性来生成hashCode()和equals()。在我们的例子中，我们使用了员工id。 Equals()必须是一致的(如果对象没有被修改，那么它必须一直返回相同的值)。 当a. = (b)时，则a.hashCode()必须与b. hashcode()相同。 如果你覆盖了一个，那么你也应该覆盖另一个。

http://parameshk.blogspot.in/2014/10/examples-of-comparable-comporator.html

Java中的Equals和Hashcode方法

它们是java.lang. object类的方法，object类是所有类(自定义类以及java API中定义的其他类)的超类。

实现:

public boolean equals(对象obj) hashCode()

public boolean equals(对象obj)

这个方法只是检查两个对象引用x和y是否引用同一个对象。例如，它检查x是否== y。

它是自反的:对于任何参考值x, x = (x)应该返回true。

它是对称的:对于任何参考值x和y，当且仅当y = (x)返回true时，x = (y)应该返回true。

它是可传递的:对于任何参考值x、y和z，如果x = (y)返回true, y = (z)返回true，则x = (z)应该返回true。

它是一致的:对于任何参考值x和y, x.equals(y)的多次调用一致返回true或一致返回false，前提是对象上的等号比较中使用的信息没有被修改。

对于任何非空参考值x, x.equals(null)应该返回 假的。

hashCode()

此方法返回调用此方法的对象的哈希码值。此方法以整数形式返回哈希码值，支持基于哈希的集合类，如Hashtable、HashMap、HashSet等。必须在重写equals方法的每个类中重写此方法。

hashCode的一般契约是:

在Java应用程序的执行过程中，只要在同一个对象上多次调用hashCode方法，hashCode方法必须一致地返回相同的整数，前提是该对象上的等号比较中使用的信息没有被修改。

这个整数不需要在应用程序的一次执行和同一应用程序的另一次执行之间保持一致。

如果根据equals(Object)方法，两个对象相等，那么在这两个对象上调用hashCode方法必须产生相同的整数结果。

如果根据equals(java.lang.Object)方法，两个对象是不相等的，那么对每个对象调用hashCode方法必须产生不同的整数结果，这是不要求的。然而，程序员应该意识到，为不相等的对象生成不同的整数结果可能会提高哈希表的性能。

相等的对象必须产生相同的哈希代码，只要它们是 相等但不相等的对象不需要产生不同的哈希码。

资源:

JavaRanch

图片

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