java equals hashcode_Java equals 方法与hashcode 方法的深入解析

PS:本文使用jdk1.7解析

1.Object类 的equals 方法

/**

* Indicates whether some other object is "equal to" this one.

*

* The {@code equals} method implements an equivalence relation

* on non-null object references:

*

*

It is reflexive: for any non-null reference value

*     {@code x}, {@code x.equals(x)} should return

*     {@code true}.

*

It is symmetric: for any non-null reference values

*     {@code x} and {@code y}, {@code x.equals(y)}

*     should return {@code true} if and only if

*     {@code y.equals(x)} returns {@code true}.

*

It is transitive: for any non-null reference values

*     {@code x}, {@code y}, and {@code z}, if

*     {@code x.equals(y)} returns {@code true} and

*     {@code y.equals(z)} returns {@code true}, then

*     {@code x.equals(z)} should return {@code true}.

*

It is consistent: for any non-null reference values

*     {@code x} and {@code y}, multiple invocations of

*     {@code x.equals(y)} consistently return {@code true}

*     or consistently return {@code false}, provided no

*     information used in {@code equals} comparisons on the

*     objects is modified.

*

For any non-null reference value {@code x},

*     {@code x.equals(null)} should return {@code false}.

*

*

* The {@code equals} method for class {@code Object} implements

* the most discriminating possible equivalence relation on objects;

* that is, for any non-null reference values {@code x} and

* {@code y}, this method returns {@code true} if and only

* if {@code x} and {@code y} refer to the same object

* ({@code x == y} has the value {@code true}).

*

* Note that it is generally necessary to override the {@code hashCode}

* method whenever this method is overridden, so as to maintain the

* general contract for the {@code hashCode} method, which states

* that equal objects must have equal hash codes.

*

* @param   obj   the reference object with which to compare.

* @return  {@code true} if this object is the same as the obj

*          argument; {@code false} otherwise.

* @see     #hashCode()

* @see     java.util.HashMap

*/

public boolean equals(Object obj) {

return (this == obj);

}

看代码,Object的equals方法,采用== 进行比较,只是比较对象的引用,如果引用的对象相同,那么就返回true.

看注释,Object的equals方法,具有如下特性

1.reflexive-自反性 x.equals(x)  return true

2.symmetric-对称性x.equals(y)  return true

y.equals(x)  return true

3.transitive-传递性x.equals(y)  return true

y.equals(z)  return true

x.equals(z)  return true

4.consistent-一致性x.equals(y)  return true //那么不管调用多少次,肯定都是返回true

5.与null的比较x.equals(null) return false //对于none-null的x对象,每次必然返回false

6.于hashcode的关系     * Note that it is generally necessary to override the {@code hashCode}

* method whenever this method is overridden, so as to maintain the

* general contract for the {@code hashCode} method, which states

* that equal objects must have equal hash codes.

需要注意的是,一般来说,如果重写了equals方法,都必须要重写hashcode方法,

来确保具有相同引用的对象,能够具有同样的hashcode值

好了,看到这里,我们就明白了,为什么重写了equals方法,一般来说就需要重写hashcode方法,

虽然这个不是强制性的,但是如果不能保证相同的引用对象,没有相同的hashcode,会对系统留下很大隐患

2.String类的equals方法

/**

* Compares this string to the specified object.  The result is {@code

* true} if and only if the argument is not {@code null} and is a {@code

* String} object that represents the same sequence of characters as this

* object.

*

* @param  anObject

*         The object to compare this {@code String} against

*

* @return  {@code true} if the given object represents a {@code String}

*          equivalent to this string, {@code false} otherwise

*

* @see  #compareTo(String)

* @see  #equalsIgnoreCase(String)

*/

public boolean equals(Object anObject) {

if (this == anObject) {

return true;

}

if (anObject instanceof String) {

String anotherString = (String) anObject;

int n = value.length;

if (n == anotherString.value.length) {

char v1[] = value;

char v2[] = anotherString.value;

int i = 0;

while (n-- != 0) {

if (v1[i] != v2[i])

return false;

i++;

}

return true;

}

}

return false;

}

看源码,我们可以发现,这个比较分为两部分1.先比较是否引用同一对象

2.如果引用对象不同,是否两个String的content相同

3,String 类的hashcode 方法

/**

* Returns a hash code for this string. The hash code for a

* String object is computed as

*

* s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

*

* using int arithmetic, where s[i] is the

* ith character of the string, n is the length of

* the string, and ^ indicates exponentiation.

* (The hash value of the empty string is zero.)

*

* @return  a hash code value for this object.

*/

public int hashCode() {

int h = hash;

if (h == 0 && value.length > 0) {

char val[] = value;

for (int i = 0; i < value.length; i++) {

h = 31 * h + val[i];

}

hash = h;

}

return h;

}

可以看到hashcode的计算公式为:s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

因此,对于同一个String,得出的hashcode必然是一致的

另外,对于空的字符串,hashcode的值是0

小结至此,我们可以对本文开头的疑问做一个小结.

1.字符串比较时用的什么方法,内部实现如何?使用equals方法,先比较引用是否相同,后比较内容是否一致.

2.hashcode的作用,以及重写equal方法,为什么要重写hashcode方法?hashcode是系统用来快速检索对象而使用,equals方法是用来判断引用的对象是否一致,所以,当引用对象一致时,必须要确保其hashcode也一致,因此需要重写hashcode方法来确保这个一致性