Java中的hashCode() 和 equals()
一、 equals() 的作用
equals() 的作用是 用來判斷兩個物件是否相等。
equals() 定義在JDK的Object.java中。通過判斷兩個物件的地址是否相等(即，是否是同一個物件)來區分它們是否相等。原始碼如下：
public boolean equals(Object obj) {
return (this == obj);
}既然Object.java中定義了equals()方法，這就意味著所有的Java類都實現了equals()方法，所有的類都可以通過equals()去比較兩個物件是否相等。 但是，我們已經說過，使用預設的“equals()
下面根據“類是否覆蓋equals()方法”，將它分為2類。
(01) 若某個類沒有覆蓋equals()方法，當它的通過equals()比較兩個物件時，實際上是比較兩個物件是不是同一個物件。這時，等價於通過“==”去比較這兩個物件。(“==”：比較是否是同一物件，即比較物件的記憶體地址是否相同)
(02) 我們可以覆蓋類的equals()方法，來讓equals()通過其它方式比較兩個物件是否相等。通常的做法是：若兩個物件的內容相等，則equals()方法返回true；否則，返回fasle。
Object類中的equals方法和“==”是一樣的，沒有區別，即倆個物件的比較是比較他們的棧記憶體中儲存的記憶體地址。而String類，Integer類等等一些類，是重寫了equals方法，才使得equals和“==不同”，他們比較的是值是不是相等。所以，當自己建立類時，自動繼承了Object的equals方法，要想實現不同的等於比較，必須重寫equals方法。
下面，舉例對上面的2種情況進行說明。
1. “沒有覆蓋equals()方法”的情況
import java.util.*;
import java.lang.Comparable;
/**
* @desc equals()的測試程式。
*
* @author skywang
* @emai 結果分析：
我們通過 p1.equals(p2) 來“比較p1和p2是否相等時”。實際上，呼叫的Object.java的equals()方法，即呼叫的 (p1==p2) 。它是比較“p1和p2是否是同一個物件”。
而由 p1 和 p2 的定義可知，它們雖然內容相同；但它們是兩個不同的物件！因此，返回結果是false。
2. "覆蓋equals()方法"的情況
我們修改上面的EqualsTest1.java：覆蓋equals()方法。
import java.util.*;
import java.lang.Comparable;
/**
* @desc equals()的測試程式。
*
* @author skywang
* @emai [email protected]
*/
public class EqualsTest2{
public static void main(String[] args) {
// 新建2個相同內容的Person物件，
// 再用equals比較它們是否相等
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
System.out.printf("%s\n", p1.equals(p2)); //結果：true
}
/**
* @desc Person類。
*/
private static class Person {
int age;
String name;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return name + " - " +age;
}
/**
* @desc 覆蓋equals方法
*/
@Override
public boolean equals(Object obj){
if(obj == null){
return false;
}
//如果是同一個物件返回true，反之返回false
if(this == obj){
return true;
}
//判斷是否型別相同
if(this.getClass() != obj.getClass()){
return false;
}
Person person = (Person)obj;
return name.equals(person.name) && age==person.age;
}
}
}結果分析：
我們在EqualsTest2.java 中重寫了Person的equals()函式：當兩個Person物件的 name 和 age 都相等，則返回true。
因此，執行結果返回true。
講到這裡，順便說一下java對equals()的要求。有以下幾點：
1. 對稱性：如果x.equals(y)返回是"true"，那麼y.equals(x)也應該返回是"true"。 2. 反射性：x.equals(x)必須返回是"true"。 3. 類推性：如果x.equals(y)返回是"true"，而且y.equals(z)返回是"true"，那麼z.equals(x)也應該返回是"true"。 4. 一致性：如果x.equals(y)返回是"true"，只要x和y內容一直不變，不管你重複x.equals(y)多少次，返回都是"true"。 5. 非空性，x.equals(null)，永遠返回是"false"；x.equals(和x不同型別的物件)永遠返回是"false"。
現在，再回顧一下equals()的作用：判斷兩個物件是否相等。當我們重寫equals()的時候，可千萬不好將它的作用給改變了！
第2部分 equals() 與 == 的區別
== : 它的作用是判斷兩個物件的地址是不是相等。即，判斷兩個物件是不試同一個物件。
equals() : 它的作用也是判斷兩個物件是否相等。但它一般有兩種使用情況(前面第1部分已詳細介紹過)：
情況1，類沒有覆蓋equals()方法。則通過equals()比較該類的兩個物件時，等價於通過“==”比較這兩個物件。
情況2，類覆蓋了equals()方法。一般，我們都覆蓋equals()方法來兩個物件的內容相等；若它們的內容相等，則返回true(即，認為這兩個物件相等)。
第3部分 hashCode() 的作用
hashCode() 的作用是獲取雜湊碼，也稱為雜湊碼；它實際上是返回一個int整數。這個雜湊碼的作用是確定該物件在雜湊表中的索引位置。
hashCode() 定義在JDK的Object.java中，這就意味著Java中的任何類都包含有hashCode() 函式。
雖然，每個Java類都包含hashCode() 函式。但是，僅僅當建立並某個“類的散列表”(關於“散列表”見下面說明)時，該類的hashCode() 才有用 (作用是：確定該類的每一個物件在散列表中的位置；其它情況下(例如，建立類的單個物件，或者建立類的物件陣列等等)，類的hashCode() 沒有作用。
上面的散列表，指的是：Java集合中本質是散列表的類，如HashMap，Hashtable，HashSet。
也就是說：hashCode() 在散列表中才有用，在其它情況下沒用。在散列表中hashCode() 的作用是獲取物件的雜湊碼，進而確定該物件在散列表中的位置。
至此，我們搞清楚了：hashCode()的作用是獲取雜湊碼。
我們都知道，散列表儲存的是鍵值對(key-value)，它的特點是：能根據“鍵”快速的檢索出對應的“值”。這其中就利用到了雜湊碼！
散列表的本質是通過陣列實現的。當我們要獲取散列表中的某個“值”時，實際上是要獲取陣列中的某個位置的元素。而陣列的位置，就是通過“鍵”來獲取的；更進一步說，陣列的位置，是通過“鍵”對應的雜湊碼計算得到的。
下面，我們以HashSet為例，來深入說明hashCode()的作用。
假設，HashSet中已經有1000個元素。當插入第1001個元素時，需要怎麼處理？因為HashSet是Set集合，它允許有重複元素。
“將第1001個元素逐個的和前面1000個元素進行比較”？顯然，這個效率是相等低下的。散列表很好的解決了這個問題，它根據元素的雜湊碼計算出元素在散列表中的位置，然後將元素插入該位置即可。對於相同的元素，自然是隻儲存了一個。
由此可知，若兩個元素相等，它們的雜湊碼一定相等；但反過來確不一定。在散列表中，
1、如果兩個物件相等，那麼它們的hashCode()值一定要相同；
2、如果兩個物件hashCode()相等，它們並不一定相等。
注意：這是在散列表中的情況。在非散列表中一定如此！
第4部分 hashCode() 和 equals() 的關係
接下面，我們討論另外一個話題。網上很多文章將 hashCode() 和 equals 關聯起來，有的講的不透徹，有誤導讀者的嫌疑。在這裡，我自己梳理了一下 “hashCode() 和 equals()的關係”。
我們以“類的用途”來將“hashCode() 和 equals()的關係”分2種情況來說明。
1. 第一種 不會建立“類對應的散列表”
這裡所說的“不會建立類對應的散列表”是說：我們不會在HashSet, Hashtable, HashMap等等這些本質是散列表的資料結構中，用到該類。例如，不會建立該類的HashSet集合。
在這種情況下，該類的“hashCode() 和 equals() ”沒有任何關係！這種情況下，equals() 用來比較該類的兩個物件是否相等。而hashCode() 則根本沒有任何作用，所以，不用理會hashCode()。
2. 第二種 會建立“類對應的散列表”
這裡所說的“會建立類對應的散列表”是說：我們會在HashSet, Hashtable, HashMap等等這些本質是散列表的資料結構中，用到該類。例如，會建立該類的HashSet集合。
在這種情況下，該類的“hashCode() 和 equals() ”是有關係的：
1)、如果兩個物件相等，那麼它們的hashCode()值一定相同。
這裡的相等是指，通過equals()比較兩個物件時返回true。
2)、如果兩個物件hashCode()相等，它們並不一定相等。
因為在散列表中，hashCode()相等，即兩個鍵值對的雜湊值相等。然而雜湊值相等，並不一定能得出鍵值對相等。補充說一句：“兩個不同的鍵值對，雜湊值相等”，這就是雜湊衝突。
此外，在這種情況下。若要判斷兩個物件是否相等，除了要覆蓋equals()之外，也要覆蓋hashCode()函式。否則，equals()無效。
例如，建立Person類的HashSet集合，必須同時覆蓋Person類的equals() 和 hashCode()方法。
如果單單只是覆蓋equals()方法。我們會發現，equals()方法沒有達到我們想要的效果。
import java.util.*;
import java.lang.Comparable;
/**
* @desc 比較equals() 返回true 以及 返回false時， hashCode()的值。
*
* @author skywang
* @emai [email protected]
*/
public class ConflictHashCodeTest1{
public static void main(String[] args) {
// 新建Person物件，
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
Person p3 = new Person("aaa", 200);
// 新建HashSet物件
HashSet set = new HashSet();
set.add(p1);
set.add(p2);
set.add(p3);
// 比較p1 和 p2， 並列印它們的hashCode()
System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
// 列印set
System.out.printf("set:%s\n", set);
}
/**
* @desc Person類。
*/
private static class Person {
int age;
String name;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "("+name + ", " +age+")";
}
/**
* @desc 覆蓋equals方法
*/
@Override
public boolean equals(Object obj){
if(obj == null){
return false;
}
//如果是同一個物件返回true，反之返回false
if(this == obj){
return true;
}
//判斷是否型別相同
if(this.getClass() != obj.getClass()){
return false;
}
Person person = (Person)obj;
return name.equals(person.name) && age==person.age;
}
}
}執行結果：
p1.equals(p2) : true; p1(1169863946) p2(1690552137) set:[(eee, 100), (eee, 100), (aaa, 200)]
結果分析：
我們重寫了Person的equals()。但是，很奇怪的發現：HashSet中仍然有重複元素：p1 和 p2。為什麼會出現這種情況呢？
這是因為雖然p1 和 p2的內容相等，但是它們的hashCode()不等；所以，HashSet在新增p1和p2的時候，認為它們不相等。
下面，我們同時覆蓋equals() 和 hashCode()方法。
參考程式碼 (ConflictHashCodeTest2.java)：
import java.util.*;
import java.lang.Comparable;
/**
* @desc 比較equals() 返回true 以及 返回false時， hashCode()的值。
*
* @author skywang
* @emai [email protected]
*/
public class ConflictHashCodeTest2{
public static void main(String[] args) {
// 新建Person物件，
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
Person p3 = new Person("aaa", 200);
Person p4 = new Person("EEE", 100);
// 新建HashSet物件
HashSet set = new HashSet();
set.add(p1);
set.add(p2);
set.add(p3);
// 比較p1 和 p2， 並列印它們的hashCode()
System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
// 比較p1 和 p4， 並列印它們的hashCode()
System.out.printf("p1.equals(p4) : %s; p1(%d) p4(%d)\n", p1.equals(p4), p1.hashCode(), p4.hashCode());
// 列印set
System.out.printf("set:%s\n", set);
}
/**
* @desc Person類。
*/
private static class Person {
int age;
String name;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return name + " - " +age;
}
/**
* @desc重寫hashCode
*/
@Override
public int hashCode(){
int nameHash = name.toUpperCase().hashCode();
return nameHash ^ age;
}
/**
* @desc 覆蓋equals方法
*/
@Override
public boolean equals(Object obj){
if(obj == null){
return false;
}
//如果是同一個物件返回true，反之返回false
if(this == obj){
return true;
}
//判斷是否型別相同
if(this.getClass() != obj.getClass()){
return false;
}
Person person = (Person)obj;
return name.equals(person.name) && age==person.age;
}
}
}執行結果：
p1.equals(p2) : true; p1(68545) p2(68545) p1.equals(p4) : false; p1(68545) p4(68545) set:[aaa - 200, eee - 100]
結果分析：
這下，equals()生效了，HashSet中沒有重複元素。
比較p1和p2，我們發現：它們的hashCode()相等，通過equals()比較它們也返回true。所以，p1和p2被視為相等。
比較p1和p4，我們發現：雖然它們的hashCode()相等；但是，通過equals()比較它們返回false。所以，p1和p4被視為不相等。
重寫equals()方法就必須重寫hashCode()方法的原因
從Object類的hashCode()和equals()方法講起：
最近看了Object類的原始碼，對hashCode() 和equals()方法有了更深的認識。重寫equals()方法就必須重寫hashCode()方法的原因，從源頭Object類講起就更好理解了。
先來看Object關於hashCode()和equals()的原始碼：
public native int hashCode();
public boolean equals(Object obj) {
return (this == obj);
}
光從程式碼中我們可以知道，hashCode()方法是一個本地native方法，返回的是物件引用中儲存的物件的記憶體地址，而equals方法是利用==來比較的也是物件的記憶體地址。從上邊我們可以看出，hashCode方法和equals方法是一致的。還有最關鍵的一點，我們來看Object類中關於hashCode()方法的註釋：
/**
* 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}.
* <p>
* 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 <em>not</em> 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>
* <p>
* 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方法一般的規定是：
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的規則。下邊，會介紹在集合框架中，這種情況會導致的嚴重問題。
重寫的作用：
如果重寫（用於需求，比如建立一個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方法，比較的是值。
重寫equals方法時需要重寫hashCode方法，主要是針對Map、Set等集合型別的使用；
a: Map、Set等集合型別存放的物件必須是唯一的；
b: 集合類判斷兩個物件是否相等，是先判斷equals是否相等，如果equals返回TRUE，還要再判斷HashCode返回值是否ture,只有兩者都返回ture,才認為該兩個物件是相等的。
2、由於Object的hashCode返回的是物件的hash值，所以即使equals返回TRUE，集合也可能判定兩個物件不等，所以必須重寫hashCode方法，以保證當equals返回TRUE時，hashCode也返回Ture，這樣才能使得集合中存放的物件唯一。
重寫hashcode的時候會用31這個數 一般寫法：
@Override
public int hashCode() {
int result = 17;
result = result * 31 + name.hashCode();
result = result * 31 + age;
return result;
} 我的理解是:
首先為了儘量讓產生hashcode保持唯一，所以一定使用一個素數來做係數（這裡的31）。
但為什麼是31而不是別的素數呢，因為：
31可以 由i*31== (i<<5)-1來表示，現在很多虛擬機器裡面都有做相關優化，使用31的原因可能是為了更好的分配hash地址，並且31只佔用5bits！
所以從效率上 它是2的5次減1，對計算機來說2的乘除操作只需要做位移操作，例如*32就是左移5位。
也就是說31對計算機的角度來說運算更快、切佔記憶體不多不少，而且形成慣例，虛擬機器甚至都專門對他做了優化。所以常用31做係數算hashcode