java中equals方法和hashcode方法的區別和聯繫，以及爲何要重寫這兩個方法，不重寫會怎樣

時間 2019-11-13

標籤 java equals 方法 hashcode 區別聯繫以及爲何重寫兩個怎樣欄目 Java 简体版

原文原文鏈接

1、在Object類中的定義爲:
public native int hashCode();
是一個本地方法，返回的對象的地址值。
可是，一樣的思路，在String等封裝類中對此方法進行了重寫。方法調用獲得一個計算公式獲得的 int值。

2、在重寫任何類得hashcode方法時必須遵循如下幾點：
一、在Java應用的同一次執行過程當中，同一對象被屢次調用，則他們的hashcode值必然相同。
而對於同一個應用的兩次不一樣的調用，它們的Hashcode值能夠相同，也有可能不一樣。
二、對於兩個對象來講，若是他們的equals方法比較返回true，那麼這兩個對象的hashcode必然相同。
這也解釋了爲何String類中，若是兩個對象的equals方法相同，則他們的hashcode值必定相同。

三、對於兩個對象來講，若是使用equals方法返回爲false，則他們的hashcode的值有可能相等也可能不等，
（若是不一樣會提升性能，由於在集合中類判斷兩個對象是否相等，若是其hashcode不等就直接不用判斷equals方法了）
四、對於Object對象來講，不一樣的Object對象的hashcode是不一樣的，它們返回的是對象的地址，
equals返回的也是對象的地址。因此在本身定義的類中若是要添加到集合對象中，
最好是要重寫hashcode和equals方法，否則會自動繼承自Object類中的兩個方法根據對象地址來判斷。
在重寫本身定義的類時，一般是在類中的根據某個值如name.hashcode();來進行判斷。

3、以HashSet 爲例：
當咱們使用HashSet時，hashCode()方法就會被獲得調用，判斷已經存儲在集合中的對象的hashCode值是否與所增長。
對象的hashCode值一致，若是「不一致」則直接加進去（不用比較equals()提升效率），若是一致，則進行equals方法的比較，若是返回true，代表集合裏面已經有這個對象，不能添加進去了。若是是false表是集合裏面沒有這個對象，則能夠加進去。因此在重寫hashcode()或者equals() 方法的任何一個方法時，必須重寫另一個。 
示例代碼：
/** 
* People 手工重寫hashcode方法和equals方法 根據name來判斷 兩個對象是否相等。 
*/ 
class People { 
private String name; 
public People(String name) { 
this.name = name; 
} 
@Override 
public boolean equals(Object obj) { 
//若是是本身 
if(this==obj){ 
return true ; 
} 
//若是是空 
if(obj==null ){ 
return false; 
} 
//比較兩個People的名字是否相同 
if(obj!=null && obj instanceof People){ 
if(((People)obj).name.equals(this.name)) 
return true ; 
} 
return false; 
} 
@Override 
public int hashCode() { 
// String的hashcode原本就是用來比較兩個字符是否相等 
return name.hashCode(); 
} 
}

從Object類的hashCode()和equals()方法講起：

最近看了Object類的源碼，對hashCode() 和equals()方法有了更深的認識。重寫equals()方法就必須重寫hashCode()方法的緣由，從源頭Object類講起就更好理解了。java

先來看Object關於hashCode()和equals()的源碼：程序員

[java] view plain copy

public native int hashCode();

[java] view plain copy

public boolean equals(Object obj) {
return (this == obj);
}

     光從代碼中咱們能夠知道，hashCode()方法是一個本地native方法，返回的是對象引用中存儲的對象的內存地址，而equals方法是利用==來比較的也是對象的內存地址。從上邊咱們能夠看出，hashCode方法和equals方法是一致的。還有最關鍵的一點，咱們來看Object類中關於hashCode()方法的註釋：

[java] view plain copy

/**
* Returns a hash code value for the object. This method is
* supported for the benefit of hash tables such as those provided by
* {@link java.util.HashMap}.
*
* The general contract of {@code hashCode} is:
* <ul>
* <li>Whenever it is invoked on the same object more than once during
* an execution of a Java application, the {@code hashCode} method
* must consistently return the same integer, provided no information
* used in {@code equals} comparisons on the object is modified.
* This integer need not remain consistent from one execution of an
* application to another execution of the same application.
* <li>If two objects are equal according to the {@code equals(Object)}
* method, then calling the {@code hashCode} method on each of
* the two objects must produce the same integer result.
* <li>It is not required that if two objects are unequal
* according to the {@link java.lang.Object#equals(java.lang.Object)}
* method, then calling the {@code hashCode} method on each of the
* two objects must produce distinct integer results. However, the
* programmer should be aware that producing distinct integer results
* for unequal objects may improve the performance of hash tables.
* </ul>
*
* As much as is reasonably practical, the hashCode method defined by
* class {@code Object} does return distinct integers for distinct
* objects. (This is typically implemented by converting the internal
* address of the object into an integer, but this implementation
* technique is not required by the
* Java™ programming language.)
*
* @return a hash code value for this object.
* @see java.lang.Object#equals(java.lang.Object)
* @see java.lang.System#identityHashCode
*/
public native int hashCode();

    簡單的翻譯一下就是，hashCode方法通常的規定是：

[java] view plain copy

1.在 Java 應用程序執行期間，在對同一對象屢次調用 hashCode 方法時，必須一致地返回相同的整數，前提是將對象進行 equals 比較時所用的信息沒有被修改。從某一應用程序的一次執行到同一應用程序的另外一次執行，該整數無需保持一致。
2.若是根據 equals(Object) 方法，兩個對象是相等的，那麼對這兩個對象中的每一個對象調用 hashCode 方法都必須生成相同的整數結果。
3.若是根據 equals(java.lang.Object) 方法，兩個對象不相等，那麼對這兩個對象中的任一對象上調用 hashCode 方法不要求必定生成不一樣的整數結果。可是，程序員應該意識到，爲不相等的對象生成不一樣整數結果能夠提升哈希表的性能。

再簡單的翻譯一下第二三點就是：hashCode()和equals()保持一致，若是equals方法返回true，那麼兩個對象的hasCode()返回值必須同樣。若是equals方法返回false，hashcode能夠不同，可是這樣不利於哈希表的性能，通常咱們也不要這樣作。重寫equals()方法就必須重寫hashCode()方法的緣由也就顯而易見了。數組

假設兩個對象，重寫了其equals方法，其相等條件是屬性相等，就返回true。若是不重寫hashcode方法，其返回的依然是兩個對象的內存地址值，必然不相等。這就出現了equals方法相等，可是hashcode不相等的狀況。這不符合hashcode的規則。下邊，會介紹在集合框架中，這種狀況會致使的嚴重問題。app

重寫的做用：

若是重寫（用於需求，好比創建一個Person類，比較相等我只比較其屬性身份證相等就可無論其餘屬性，這時候重寫）equals，就得重寫hashCode，和其對象相等保持一致。若是不重寫，那麼調用的Object中的方法必定保持一致。

1. 重寫equals()方法就必須重寫hashCode()方法主要是針對HashSet和Map集合類型。集合框架只能存入對象（對象的引用（基本類型數據：自動裝箱））。

在向HashSet集合中存入一個元素時，HashSet會調用該對象（存入對象）的hashCode()方法來獲得該對象的hashCode()值，而後根據該hashCode值決定該對象在HashSet中存儲的位置。簡單的說：HashSet集合判斷兩個元素相等的標準是：兩個對象經過equals()方法比較相等，而且兩個對象的HashCode()方法返回值也相等。若是兩個元素經過equals()方法比較返回true，可是它們的hashCode()方法返回值不一樣，HashSet會把它們存儲在不一樣的位置，依然能夠添加成功。一樣：在Map集合中，例如其子類Hashtable（jdk1.0錯誤的命名規範），HashMap，存儲的數據是<key,value>對，key，value都是對象，被封裝在Map.Entry，即：每一個集合元素都是Map.Entry對象。在Map集合中，判斷key相等標準也是：兩個key經過equals()方法比較返回true，兩個key的hashCode的值也必須相等。判斷valude是否相等equal()相等便可。

稍微提一句：（1）兩個對象，用==比較比較的是地址，需採用equals方法（可根據需求重寫）比較。

（2）重寫equals()方法就重寫hashCode()方法。

（3）通常相等的對象都規定有相同的hashCode。

hash：散列，Map關聯數組，字典

2. 集合類都重寫了toString方法。String類重寫了equal和hashCode方法，比較的是值。

用HashSet來驗證兩個需都重寫的必要性

程序提供了三個類A,B,C，它們分別重寫了equals()，hashCode()兩個方法中的一個或所有。

class A {
String certificate;框架

public A(String certificate) {ide

this.certificate = certificate;
}性能

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

}this

class B {
String certificate;// 身份證號spa

public B(String certificate) {

this.certificate = certificate;
}

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

class C {
String certificate;

public C(String certificate) {

this.certificate = certificate;
}

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

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

}

package day02;

import java.util.HashSet;

public class EqualsHashcodeDemo {
public static void main(String[] args) {

HashSet<A> hashSetA = new HashSet();
hashSetA.add(new A("123"));
hashSetA.add(new A("123"));
for (Object hs : hashSetA) {
System.out.println(hs);
}

HashSet hashSetB = new HashSet();
hashSetB.add(new B("345"));
hashSetB.add(new B("345"));
for (Object hs : hashSetB) {
System.out.println(hs);
}
HashSet<C> hashSetC = new HashSet<C>();
hashSetC.add(new C("456"));
hashSetC.add(new C("456"));
for (Object hs : hashSetC) {
System.out.println(hs);
}
/**
* 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; }
*/