为什么我需要重写Java中的equals和hashCode方法?

最近我读了这篇文章开发人员工作文件。

该文档是关于有效和正确地定义hashCode()和equals()，但我无法弄清楚为什么我们需要覆盖这两个方法。

我如何决定有效地实现这些方法?

当前回答

如果重写equals()而不是hashcode()，则不会发现任何问题，除非您或其他人在HashSet等散列集合中使用该类类型。在我之前的人已经清楚地解释了很多次文献理论，我只是在这里提供一个非常简单的例子。

考虑一个类，它的equals()需要表示自定义的东西:-

    public class Rishav {

        private String rshv;

        public Rishav(String rshv) {
            this.rshv = rshv;
        }

        /**
        * @return the rshv
        */
        public String getRshv() {
            return rshv;
        }

        /**
        * @param rshv the rshv to set
        */
        public void setRshv(String rshv) {
            this.rshv = rshv;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj instanceof Rishav) {
                obj = (Rishav) obj;
                if (this.rshv.equals(((Rishav) obj).getRshv())) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }

        @Override
        public int hashCode() {
            return rshv.hashCode();
        }

    }

现在考虑这个主类:-

    import java.util.HashSet;
    import java.util.Set;

    public class TestRishav {

        public static void main(String[] args) {
            Rishav rA = new Rishav("rishav");
            Rishav rB = new Rishav("rishav");
            System.out.println(rA.equals(rB));
            System.out.println("-----------------------------------");

            Set<Rishav> hashed = new HashSet<>();
            hashed.add(rA);
            System.out.println(hashed.contains(rB));
            System.out.println("-----------------------------------");

            hashed.add(rB);
            System.out.println(hashed.size());
        }

    }

这将产生以下输出:-

    true
    -----------------------------------
    true
    -----------------------------------
    1

我对结果很满意。但是如果我没有覆盖hashCode()，它将导致噩梦，因为具有相同成员内容的Rishav对象将不再被视为唯一的hashCode将是不同的，因为由默认行为生成，这里将是输出:-

    true
    -----------------------------------
    false
    -----------------------------------
    2

2020-03-12 11:45:45

其他回答

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()时，它可以比较内容并给出正确的结果。

2018-07-17 10:39:33

我正在研究解释“如果你只覆盖hashCode，那么当你调用myMap.put(first,someValue)时，它首先接受，计算它的hashCode并将其存储在给定的桶中。然后，当你调用myMap.put(first,someOtherValue)时，它应该根据Map文档将first替换为second，因为它们是相等的(根据我们的定义)。”：

我认为第二次添加myMap时应该是第二个对象比如myMap。put(second,someOtherValue)

2010-11-12 05:49:00

简单地说，Object中的equals-方法检查引用是否相等，当属性相等时，类的两个实例在语义上仍然相等。例如，当将对象放入使用等号和hashcode(如HashMap和Set)的容器中时，这很重要。假设我们有这样一个类:

public class Foo {
    String id;
    String whatevs;

    Foo(String id, String whatevs) {
        this.id = id;
        this.whatevs = whatevs;
    }
}

我们创建了两个具有相同id的实例:

Foo a = new Foo("id", "something");
Foo b = new Foo("id", "something else");

如果不重写等号，我们将得到:

A.equals (b)为假，因为它们是两个不同的实例 a.equals(a)为真，因为它是同一个实例 b.equals(b)为真，因为它是同一个实例

正确吗?也许吧，如果这是你想要的。但假设我们希望具有相同id的对象是相同的对象，不管它是否是两个不同的实例。我们重写等号(和hashcode):

public class Foo {
    String id;
    String whatevs;

    Foo(String id, String whatevs) {
        this.id = id;
        this.whatevs = whatevs;
    }

    @Override
    public boolean equals(Object other) {
        if (other instanceof Foo) {
            return ((Foo)other).id.equals(this.id);   
        }
    }

    @Override
    public int hashCode() {
        return this.id.hashCode();
    }
}

至于实现equals和hashcode，我建议使用Guava的helper方法

2010-02-15 11:29:45

Java提出了一个规则

如果使用Object类的equals方法，两个对象相等，那么hashcode方法应该为这两个对象提供相同的值。

因此，如果在我们的类中重写equals()，我们也应该重写hashcode()方法来遵循此规则。例如，equals()和hashcode()这两个方法都用于Hashtable中以键值对的形式存储值。如果我们覆盖其中一个而不是另一个，如果我们使用这样的对象作为键，哈希表可能不会像我们想要的那样工作。