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

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

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

首先，从更广泛的角度来看，我们有集合，而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());
    }
}

在这个回答中没有提到测试equals/hashcode契约。

我发现EqualsVerifier库非常有用和全面。它也很容易使用。

另外，从头构建equals()和hashCode()方法涉及大量样板代码。Apache Commons Lang库提供了EqualsBuilder和HashCodeBuilder类。这些类极大地简化了复杂类的equals()和hashCode()方法的实现。

顺便说一句，值得考虑重写toString()方法以帮助调试。Apache Commons Lang库提供了ToStringBuilder类来帮助实现这一点。

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

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

public class Employee {

    private int empId;
    private String empName;

    public Employee(int empId, String empName) {
        super();
        this.empId = empId;
        this.empName = empName;
    }

    public int getEmpId() {
        return empId;
    }

    public void setEmpId(int empId) {
        this.empId = empId;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    @Override
    public String toString() {
        return "Employee [empId=" + empId + ", empName=" + empName + "]";
    }

    @Override
    public int hashCode() {
        return empId + empName.hashCode();
    }

    @Override
    public boolean equals(Object obj) {

        if (this == obj) {
            return true;
        }
        if (!(this instanceof Employee)) {
            return false;
        }
        Employee emp = (Employee) obj;
        return this.getEmpId() == emp.getEmpId() && this.getEmpName().equals(emp.getEmpName());
    }

}

测试类

public class Test {

    public static void main(String[] args) {
        Employee emp1 = new Employee(101,"Manash");
        Employee emp2 = new Employee(101,"Manash");
        Employee emp3 = new Employee(103,"Ranjan");
        System.out.println(emp1.hashCode());
        System.out.println(emp2.hashCode());
        System.out.println(emp1.equals(emp2));
        System.out.println(emp1.equals(emp3));
    }

}

在对象类中，equals(Object obj)用于比较地址比较，这就是为什么在Test类中，如果你比较两个对象，则equals method给出false，但当我们重写hashcode()时，它可以比较内容并给出正确的结果。

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

就是这样!