Java中的Equals和Hashcode方法

它们是java.lang. object类的方法，object类是所有类(自定义类以及java API中定义的其他类)的超类。

实现:

public boolean equals(对象obj) hashCode()

public boolean equals(对象obj)

这个方法只是检查两个对象引用x和y是否引用同一个对象。例如，它检查x是否== y。

它是自反的:对于任何参考值x, x = (x)应该返回true。

它是对称的:对于任何参考值x和y，当且仅当y = (x)返回true时，x = (y)应该返回true。

它是可传递的:对于任何参考值x、y和z，如果x = (y)返回true, y = (z)返回true，则x = (z)应该返回true。

它是一致的:对于任何参考值x和y, x.equals(y)的多次调用一致返回true或一致返回false，前提是对象上的等号比较中使用的信息没有被修改。

对于任何非空参考值x, x.equals(null)应该返回 假的。

hashCode()

此方法返回调用此方法的对象的哈希码值。此方法以整数形式返回哈希码值，支持基于哈希的集合类，如Hashtable、HashMap、HashSet等。必须在重写equals方法的每个类中重写此方法。

hashCode的一般契约是:

在Java应用程序的执行过程中，只要在同一个对象上多次调用hashCode方法，hashCode方法必须一致地返回相同的整数，前提是该对象上的等号比较中使用的信息没有被修改。

这个整数不需要在应用程序的一次执行和同一应用程序的另一次执行之间保持一致。

如果根据equals(Object)方法，两个对象相等，那么在这两个对象上调用hashCode方法必须产生相同的整数结果。

如果根据equals(java.lang.Object)方法，两个对象是不相等的，那么对每个对象调用hashCode方法必须产生不同的整数结果，这是不要求的。然而，程序员应该意识到，为不相等的对象生成不同的整数结果可能会提高哈希表的性能。

相等的对象必须产生相同的哈希代码，只要它们是 相等但不相等的对象不需要产生不同的哈希码。

资源:

JavaRanch

图片

class A {
    int i;
    // Hashing Algorithm
    if even number return 0 else return 1
    // Equals Algorithm,
    if i = this.i return true else false
}

put('key'，'value')将使用hashCode()计算哈希值来确定 桶，并使用equals()方法查找该值是否已经 出现在桶里。如果不是，它将被添加，否则它将被替换为当前值 get('key')将使用hashCode()首先找到条目(桶) equals()来查找Entry中的值

如果两者都被覆盖，

地图<A>

Map.Entry 1 --> 1,3,5,...
Map.Entry 2 --> 2,4,6,...

If =没有被覆盖

地图<A>

Map.Entry 1 --> 1,3,5,...,1,3,5,... // Duplicate values as equals not overridden
Map.Entry 2 --> 2,4,6,...,2,4,..

如果hashCode没有被覆盖

地图<A>

Map.Entry 1 --> 1
Map.Entry 2 --> 2
Map.Entry 3 --> 3
Map.Entry 4 --> 1
Map.Entry 5 --> 2
Map.Entry 6 --> 3 // Same values are Stored in different hasCodes violates Contract 1
So on...

HashCode等价契约

根据equal方法，两个相等的键应该生成相同的hashCode 生成相同hashCode的两个key不需要相等(在上面的例子中，所有偶数生成相同的hashCode)

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

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

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

它在使用值对象时很有用。以下摘自Portland Pattern Repository:

Examples of value objects are things like numbers, dates, monies and strings. Usually, they are small objects which are used quite widely. Their identity is based on their state rather than on their object identity. This way, you can have multiple copies of the same conceptual value object. So I can have multiple copies of an object that represents the date 16 Jan 1998. Any of these copies will be equal to each other. For a small object such as this, it is often easier to create new ones and move them around rather than rely on a single object to represent the date. A value object should always override .equals() in Java (or = in Smalltalk). (Remember to override .hashCode() as well.)

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

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

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

Joshua Bloch在Effective Java上说

必须在重写equals()的每个类中重写hashCode()。如果不这样做，将违反Object.hashCode()的一般约定，这将阻止您的类与所有基于哈希的集合(包括HashMap、HashSet和Hashtable)一起正常运行。

让我们通过一个例子来理解它，如果我们重写equals()而不重写hashCode()并尝试使用Map会发生什么。

假设我们有这样一个类，如果MyClass的两个对象的importantField相等(使用eclipse生成的hashCode()和equals())，则MyClass的两个对象相等

public class MyClass {
    private final String importantField;
    private final String anotherField;

    public MyClass(final String equalField, final String anotherField) {
        this.importantField = equalField;
        this.anotherField = anotherField;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result
                + ((importantField == null) ? 0 : importantField.hashCode());
        return result;
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final MyClass other = (MyClass) obj;
        if (importantField == null) {
            if (other.importantField != null)
                return false;
        } else if (!importantField.equals(other.importantField))
            return false;
        return true;
    }
}

想象一下你有这个

MyClass first = new MyClass("a","first");
MyClass second = new MyClass("a","second");

只覆盖等于

如果只有equals被覆盖，那么当你调用myMap.put(first,someValue)首先将哈希到某个桶，当你调用myMap.put(second,someOtherValue)它将哈希到其他一些桶(因为它们有不同的hashCode)。所以，尽管它们是相等的，因为它们不散列到同一个桶，映射无法意识到这一点，它们都留在映射中。

虽然如果重写hashCode()就没有必要重写equals()，但让我们看看在这种特殊情况下会发生什么:我们知道MyClass的两个对象是相等的，如果它们的importantField相等，但我们没有重写equals()。

只覆盖hashCode

如果你只覆盖hashCode，那么当你调用myMap.put(first,someValue)时，它首先接受，计算它的hashCode并将其存储在给定的bucket中。然后，当您调用myMap.put(second,someOtherValue)时，它应该根据Map文档将first替换为second，因为它们是相等的(根据业务需求)。

但问题是，equals没有被重新定义，所以当map哈希second并遍历bucket时，寻找是否有一个对象k，使得second.equals(k)为真，它不会找到任何对象，因为second.equals(first)将为假。

希望这是清楚的