Why should we rewrite hashcode when we rewrite the equals method?

Why do I need to override the equals and hashCode methods in Java?

There are various answers to this question in China , So I went to Stackoverflow I have checked the solution of this problem

Foreign for override the equals and hashCode The explanation of is more contract( contract , Meaning of contract ), in other words , rewrite equals Must be rewritten hashcode Has reached a contract ( Or rather, Theorem ?)

---

This article comes from the analysis of this comment

Why do I need to override the equals and hashCode methods in Java?

The author answers like this :

image HashMap and HashSet Is through the object hashcode To store objects , And when locating objects, you can also use hashcode

Hash retrieval is a two-step process .

1. Find the right bucket ( Use hashCode())

2. Search the bucket for the correct element ( Use equals())

Here is a small example , Explain why we rewrite equals() And need to rewrite hashcode()

Build a Employee class , It has two variables age and name

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 out 
    /*  @Override
        public int hashCode() {
            int result=17;
            result=31*result+age;
            result=31*result+(name!=null ? name.hashCode():0);
            return result;
        }
     */
}

Create a test class ClientTest

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());
    }
}

There are notes When , He'll print it out

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

Now we uncomment hashcode(), He'll print it out

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

In the first case , Two objects As like as two peas , however hashcode Dissimilarity ( Even if equals() Method is overridden ,hashcode It's still different )

But we Think employee and employee2 yes equally Of ( If we add 100 m name="rajeev",age=24 The object of , that Hashset There will be 100 Ten thousand such " identical " The object of , That's clearly not what we want )

If the traditional hashcode() Method cannot reflect this , Then we need rewrite hashcode() Method . Make two objects equal , Their hash codes are also equal