让我用非常简单的话来解释这个概念。

首先，从更广泛的角度来看，我们有集合，而hashmap是集合中的数据结构之一。

要理解为什么我们必须重写equals和hashcode方法，如果需要的话，首先要理解什么是hashmap以及它的功能。

hashmap是一种以数组方式存储键值对数据的数据结构。假设是a[]，其中'a'中的每个元素都是一个键值对。

此外，上述数组中的每个索引都可以是链表，因此在一个索引上有多个值。

为什么要使用hashmap呢?

如果我们必须在一个大数组中搜索，那么搜索每个数组，如果它们不是有效的，那么哈希技术告诉我们，让我们用一些逻辑预处理数组，并根据该逻辑对元素进行分组，即哈希

例如:我们有数组1、2、3、4、5、6、7、8、9、10、11，我们应用哈希函数mod 10，所以1、11将被分组在一起。因此，如果我们必须在前一个数组中搜索11，那么我们必须迭代整个数组，但当我们对它进行分组时，我们限制了迭代的范围，从而提高了速度。为了简单起见，用于存储所有上述信息的数据结构可以看作是一个2d数组

现在除了上面的hashmap还告诉它不会在其中添加任何duplicate。这就是为什么我们要重写等号和hashcode的主要原因

因此，当我们说要解释hashmap的内部工作时，我们需要找到hashmap有什么方法，以及它如何遵循上面我解释过的规则

所以hashmap有一个方法叫as put(K,V)，根据hashmap，它应该遵循上面的规则，有效地分配数组，不添加任何重复

put所做的是首先为给定的键生成hashcode来决定值应该放在哪个索引中。如果那个下标处什么都没有，那么新值就会被加到那里，如果那里已经有了，那么新值就会被加到链表末尾那个下标处。但是请记住，不应该根据期望的hashmap行为添加重复项。假设你有两个整数对象aa=11 bb=11。

由于每个对象都派生自对象类，比较两个对象的默认实现是比较引用，而不是对象内部的值。因此，在上述情况下，尽管语义上相同，但两个对象都将无法通过相等性测试，并且有可能存在两个具有相同hashcode和相同值的对象，从而创建重复的对象。如果我们重写，就可以避免添加重复项。 您也可以参考详细工作

import java.util.HashMap;


public class Employee {
    String name;
    String mobile;

    public Employee(String name,String mobile) {
        this.name = name;
        this.mobile = mobile;
    }
    
    @Override
    public int hashCode() {
        System.out.println("calling hascode method of Employee");
        String str = this.name;
        int sum = 0;
        for (int i = 0; i < str.length(); i++) {
            sum = sum + str.charAt(i);
        }
        return sum;
    }

    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        System.out.println("calling equals method of Employee");
        Employee emp = (Employee) obj;
        if (this.mobile.equalsIgnoreCase(emp.mobile)) {
            System.out.println("returning true");
            return true;
        } else {
            System.out.println("returning false");
            return false;
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Employee emp = new Employee("abc", "hhh");
        Employee emp2 = new Employee("abc", "hhh");
        HashMap<Employee, Employee> h = new HashMap<>();
        //for (int i = 0; i < 5; i++) {
            h.put(emp, emp);
            h.put(emp2, emp2);
        //}
        
        System.out.println("----------------");
        System.out.println("size of hashmap: "+h.size());
    }
}

你必须重写hashCode()在每个 重写equals()的类。失败 这样做会导致违反 总合同 Object.hashCode()，它将防止 你的类不能正常运行 结合所有基于哈希的 集合，包括HashMap， HashSet和Hashtable。 摘自Joshua Bloch的《Effective Java》

通过一致地定义equals()和hashCode()，可以提高类作为基于散列的集合中的键的可用性。正如hashCode的API文档所解释的那样:“支持此方法是为了受益于诸如java.util.Hashtable所提供的哈希表。”

关于如何有效地实现这些方法的问题，最好的答案是建议你阅读《Effective Java》的第3章。

让我用非常简单的话来解释这个概念。

首先，从更广泛的角度来看，我们有集合，而hashmap是集合中的数据结构之一。

要理解为什么我们必须重写equals和hashcode方法，如果需要的话，首先要理解什么是hashmap以及它的功能。

hashmap是一种以数组方式存储键值对数据的数据结构。假设是a[]，其中'a'中的每个元素都是一个键值对。

此外，上述数组中的每个索引都可以是链表，因此在一个索引上有多个值。

为什么要使用hashmap呢?

如果我们必须在一个大数组中搜索，那么搜索每个数组，如果它们不是有效的，那么哈希技术告诉我们，让我们用一些逻辑预处理数组，并根据该逻辑对元素进行分组，即哈希

例如:我们有数组1、2、3、4、5、6、7、8、9、10、11，我们应用哈希函数mod 10，所以1、11将被分组在一起。因此，如果我们必须在前一个数组中搜索11，那么我们必须迭代整个数组，但当我们对它进行分组时，我们限制了迭代的范围，从而提高了速度。为了简单起见，用于存储所有上述信息的数据结构可以看作是一个2d数组

现在除了上面的hashmap还告诉它不会在其中添加任何duplicate。这就是为什么我们要重写等号和hashcode的主要原因

因此，当我们说要解释hashmap的内部工作时，我们需要找到hashmap有什么方法，以及它如何遵循上面我解释过的规则

所以hashmap有一个方法叫as put(K,V)，根据hashmap，它应该遵循上面的规则，有效地分配数组，不添加任何重复

put所做的是首先为给定的键生成hashcode来决定值应该放在哪个索引中。如果那个下标处什么都没有，那么新值就会被加到那里，如果那里已经有了，那么新值就会被加到链表末尾那个下标处。但是请记住，不应该根据期望的hashmap行为添加重复项。假设你有两个整数对象aa=11 bb=11。

由于每个对象都派生自对象类，比较两个对象的默认实现是比较引用，而不是对象内部的值。因此，在上述情况下，尽管语义上相同，但两个对象都将无法通过相等性测试，并且有可能存在两个具有相同hashcode和相同值的对象，从而创建重复的对象。如果我们重写，就可以避免添加重复项。 您也可以参考详细工作

import java.util.HashMap;


public class Employee {
    String name;
    String mobile;

    public Employee(String name,String mobile) {
        this.name = name;
        this.mobile = mobile;
    }
    
    @Override
    public int hashCode() {
        System.out.println("calling hascode method of Employee");
        String str = this.name;
        int sum = 0;
        for (int i = 0; i < str.length(); i++) {
            sum = sum + str.charAt(i);
        }
        return sum;
    }

    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        System.out.println("calling equals method of Employee");
        Employee emp = (Employee) obj;
        if (this.mobile.equalsIgnoreCase(emp.mobile)) {
            System.out.println("returning true");
            return true;
        } else {
            System.out.println("returning false");
            return false;
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Employee emp = new Employee("abc", "hhh");
        Employee emp2 = new Employee("abc", "hhh");
        HashMap<Employee, Employee> h = new HashMap<>();
        //for (int i = 0; i < 5; i++) {
            h.put(emp, emp);
            h.put(emp2, emp2);
        //}
        
        System.out.println("----------------");
        System.out.println("size of hashmap: "+h.size());
    }
}

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

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

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

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.

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生成的。所以让这个方法根据你的需求生成哈希码，因为相同的哈希码条目集将存储在相同的桶或索引中。

就是这样!