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

这两个方法都在Object类中定义。两者都是最简单的实现。所以当你需要你想给这些方法添加更多的实现时你就可以在你的类中重写。

对于对象中的equals()方法只检查它在引用上的相等性。如果你也需要比较它的状态，那么你可以像在String类中那样重写它。

HashMap和HashSet等集合使用对象的hashcode值来确定该对象应该如何存储在集合中，然后再次使用hashcode来定位该对象 在它的收藏中。

哈希检索是一个两步过程:

找到正确的桶(使用hashCode()) 在桶中搜索正确的元素(使用equals())

下面是一个关于为什么我们应该重写equals()和hashcode()的小例子。

考虑一个Employee类，它有两个字段:年龄和名字。

public class Employee {

    String name;
    int age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this)
            return true;
        if (!(obj instanceof Employee))
            return false;
        Employee employee = (Employee) obj;
        return employee.getAge() == this.getAge()
                && employee.getName() == this.getName();
    }

    // commented    
    /*  @Override
        public int hashCode() {
            int result=17;
            result=31*result+age;
            result=31*result+(name!=null ? name.hashCode():0);
            return result;
        }
     */
}

现在创建一个类，将Employee对象插入到HashSet中并测试该对象是否存在。

public class ClientTest {
    public static void main(String[] args) {
        Employee employee = new Employee("rajeev", 24);
        Employee employee1 = new Employee("rajeev", 25);
        Employee employee2 = new Employee("rajeev", 24);

        HashSet<Employee> employees = new HashSet<Employee>();
        employees.add(employee);
        System.out.println(employees.contains(employee2));
        System.out.println("employee.hashCode():  " + employee.hashCode()
        + "  employee2.hashCode():" + employee2.hashCode());
    }
}

它将打印以下内容:

false
employee.hashCode():  321755204  employee2.hashCode():375890482

现在uncomment hashcode()方法，执行相同的方法，输出将是:

true
employee.hashCode():  -938387308  employee2.hashCode():-938387308

Now can you see why if two objects are considered equal, their hashcodes must also be equal? Otherwise, you'd never be able to find the object since the default hashcode method in class Object virtually always comes up with a unique number for each object, even if the equals() method is overridden in such a way that two or more objects are considered equal. It doesn't matter how equal the objects are if their hashcodes don't reflect that. So one more time: If two objects are equal, their hashcodes must be equal as well.

考虑在一个桶中收集所有黑色的球。你的工作是像下面这样给这些球上色，并将其用于适当的游戏，

对于网球-黄色，红色。 板球-白色

现在水桶有三种颜色的球黄色，红色和白色。只有你知道哪个颜色适合哪个游戏。

给球上色-哈希。 选择比赛的球-平等。

如果你给球上色，然后有人选了板球或网球，他们不会介意颜色的!!

为什么重写equals()方法

在Java中，我们不能重载==、+=、-+等操作符的行为。他们的行为是特定的。让我们关注一下这里的运算符==。

operator ==如何工作。

它检查我们比较的两个引用是否指向内存中的同一个实例。只有当这两个引用表示内存中的同一个实例时，Operator ==才会解析为true。

现在让我们考虑下面的例子

public class Person {

      private Integer age;
      private String name;
    
      ..getters, setters, constructors
      }

假设在你的程序中，你在不同的地方建立了2个Person对象，你希望比较它们。

Person person1 = new Person("Mike", 34);
Person person2 = new Person("Mike", 34);
System.out.println ( person1 == person2 );  --> will print false!

这两个对象从商业角度看是一样的，对吧?对于JVM，它们是不一样的。因为它们都是用new关键字创建的，所以这些实例位于内存中的不同段中。因此运算符==将返回false

但是如果我们不能重写==操作符，我们怎么能对JVM说我们希望这两个对象被视为相同的。这里出现了.equals()方法。

您可以重写equals()来检查某些对象是否具有相同的值，以便将特定字段视为相等。

您可以选择要比较的字段。如果我们说2个Person对象当且仅当它们具有相同的年龄和相同的名称时是相同的，那么IDE将为自动生成equals()创建如下内容

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                name.equals(person.name);
    }

让我们回到前面的例子

    Person person1 = new Person("Mike", 34);
    Person person2 = new Person("Mike", 34);
    System.out.println ( person1 == person2 );   --> will print false!
    System.out.println ( person1.equals(person2) );  --> will print true!

所以我们不能重载==运算符来以我们想要的方式比较对象，但是Java给了我们另一种方法，equals()方法，我们可以随心所欲地重写它。

但是请记住，如果我们没有在我们的类中提供.equals()的自定义版本(也就是重写)，那么Object类和==操作符中预定义的.equals()将表现完全相同。

从Object继承的默认equals()方法将检查两个比较实例在内存中是否相同!

为什么重写hashCode()方法

java中的一些数据结构(如HashSet, HashMap)基于应用于这些元素上的哈希函数来存储它们的元素。哈希函数是hashCode()

如果我们可以选择重写.equals()方法，那么我们也必须选择重写hashCode()方法。这是有原因的。

继承自Object的hashCode()的默认实现认为内存中的所有对象都是唯一的!

让我们回到哈希数据结构。对于这些数据结构有一个规则。

HashSet不能包含重复的值，HashMap不能包含重复的键

HashSet是在幕后使用HashMap实现的，HashSet的每个值都存储为HashMap中的一个键。

所以我们必须理解HashMap是如何工作的。

简单地说，HashMap是一个具有一些桶的原生数组。每个桶都有一个linkedList。在那个linkedList中存储了我们的键。HashMap通过应用hashCode()方法为每个键定位正确的linkedList，然后它遍历该linkedList中的所有元素，并对每个元素应用equals()方法，以检查该元素是否已经包含在其中。不允许重复密钥。

当我们在HashMap中放东西时，键就存储在其中一个linkedlist中。该键将存储在哪个linkedList中，由该键上的hashCode()方法的结果显示。因此，如果key1. hashcode()的结果是4，那么key1将存储在数组的第4个桶中，在那里存在的linkedList中。

默认情况下，hashCode()方法为每个不同的实例返回不同的结果。如果我们有默认的equals()，它的行为类似于==，它将内存中的所有实例视为不同的对象，我们就没有任何问题。

但在前面的示例中，我们说过，如果Person实例的年龄和名字匹配，则认为Person实例是相等的。

    Person person1 = new Person("Mike", 34);
    Person person2 = new Person("Mike", 34);
    System.out.println ( person1.equals(person2) );  --> will print true!

现在让我们创建一个映射，将这些实例存储为键，并使用一些字符串作为pair值

Map<Person, String> map = new HashMap();
map.put(person1, "1");
map.put(person2, "2");

在Person类中，我们没有重写hashCode方法，但我们重写了equals方法。由于默认的hashCode为不同的java实例提供不同的结果，person1.hashCode()和person2.hashCode()很有可能得到不同的结果。

我们的映射可能以这些人在不同的链表中结束。

这违背了HashMap的逻辑

一个HashMap不允许有多个相等的键!

但是我们现在有了，原因是从对象类继承的默认hashCode()是不够的。在Person类上重写equals()方法之后就不会了。

这就是为什么我们必须在重写equals方法之后重写hashCode()方法的原因。

现在我们来解决这个问题。让我们重写hashCode()方法来考虑equals()考虑的相同字段，即年龄、姓名

 public class Person {

      private Integer age;
      private String name;
    
      ..getters, setters, constructors

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

      }

现在让我们再次尝试将这些键保存到HashMap中

Map<Person, String> map = new HashMap();
map.put(person1, "1");
map.put(person2, "2");

person1.hashCode()和person2.hashCode()肯定是相同的。假设它是0。

HashMap将进入0桶，在LinkedList中将person1保存为值为“1”的键。对于第二次放置HashMap是足够智能的，当它再次到bucket 0保存值为“2”的person2 key时，它将看到另一个相等的key已经存在于那里。它会覆盖之前的键。最后HashMap中只有person2键。

现在我们与哈希映射规则保持一致，该规则说不允许有多个相等的键!

String类和包装器类的equals()和hashCode()方法实现与Object类不同。Object类的equals()方法比较对象的引用，而不是内容。Object类的hashCode()方法为每个对象返回不同的hashCode，无论内容是否相同。

It leads problem when you use Map collection and the key is of Persistent type, StringBuffer/builder type. Since they don't override equals() and hashCode() unlike String class, equals() will return false when you compare two different objects even though both have same contents. It will make the hashMap storing same content keys. Storing same content keys means it is violating the rule of Map because Map doesnt allow duplicate keys at all. Therefore you override equals() as well as hashCode() methods in your class and provide the implementation(IDE can generate these methods) so that they work same as String's equals() and hashCode() and prevent same content keys.

你必须重写hashCode()方法和equals()，因为equals()根据hashCode工作。

此外，与equals()一起重写hashCode()方法有助于完好无损equals()-hashCode()契约:“如果两个对象相等，那么它们必须具有相同的哈希码。”

什么时候需要为hashCode()编写自定义实现?

正如我们所知，HashMap的内部工作是基于哈希原理的。条目集存储在特定的存储桶中。您可以根据自己的需求定制hashCode()实现，以便相同的类别对象可以存储在相同的索引中。 当你使用put(k,v)方法将值存储到Map集合中时，put()的内部实现是:

put(k, v){
hash(k);
index=hash & (n-1);
}

意思是，它生成索引，索引是基于特定键对象的hashcode生成的。所以让这个方法根据你的需求生成哈希码，因为相同的哈希码条目集将存储在相同的桶或索引中。

就是这样!