今天看了一片出自百度文庫的一篇關於java對象中equals()和hashcode()函數的用法，感覺很清晰，於是就把他整理了一下。
百度文庫地址:http://wenku.baidu.com/view/9070f05c312b3169a451a4af.html
有許多人學了很長時間的Java，但一直不明白hashCode方法的作用，我來解釋一下吧。首先，想要明白hashCode的作用，你必須要先知道Java中的集合。 總的來說，Java中的集合（Collection）有兩類，一類是List，再有一類是Set。
——————————————————————————————————
PS:關於java的集合框架在這多說兩句：
Java2的集合框架，主要有三種：List、Set和Map，其中List和Set是繼承Collection，需要注意的是，這裏的 Collection、List、Set和Map都是接口（Interface），不是具體的類實現。
常用集合類的繼承結構如下：
Collection<--List<--Vector
Collection<--List<--ArrayList
Collection<--List<--LinkedList
Collection<--Set<--HashSet
Collection<--Set<--HashSet<--LinkedHashSet
Collection<--Set<--SortedSet<--TreeSet
Map<--SortedMap<--TreeMap
Map<--HashMap
List
List是有序的Collection，使用此接口能夠精確的控制每個元素插入的位置。用戶能夠使用索引（元素在List中的位置，類似於數組下 >標）來訪問List中的元素，這類似於Java的數組。
Set
Set是一種不包含重複的元素的無序Collection。
Map
Map 是一種把鍵對象和值對象進行關聯的容器，而一個值對象又可以是一個Map，依次類推，這樣就可形成一個多級映射。對於鍵對象來說，像Set一樣，一個 Map容器中的鍵對象不允許重複，這是爲了保持查找結果的一致性;如果有兩個鍵對象一樣，那你想得到那個鍵對象所對應的值對象時就有問題了，可能你得到的並不是你想的那個值對象，結果會造成混亂，所以鍵的唯一性很重要，也是符合集合的性質的
一、幾個常用類的區別
1．ArrayList: 元素單個，效率高，多用於查詢
2．Vector: 元素單個，線程安全，多用於查詢
3．LinkedList:元素單個，多用於插入和刪除
4．HashMap: 元素成對，元素可爲空
5．HashTable: 元素成對，線程安全，元素不可爲空
三、Collections和Arrays
在 Java集合類框架裏有兩個類叫做Collections（注意，不是Collection！）和Arrays，這是JCF裏面功能強大的工具，但初學者往往會忽視。按JCF文檔的說法，這兩個類提供了封裝器實現（Wrapper Implementations）、數據結構算法和數組相關的應用
——————————————————————————————————
你知道它們的區別嗎？前者集合內的元素是有序的，元素可以重複；後者元素無序，但元素不可重複。那麼這裏就有一個比較嚴重的問題了：要想保證元素不重複，可兩個元素是否重複應該依據什麼來判斷呢？這就是Object.equals方法了。但是，如果每增加一個元素就檢查一次，那麼當元素很多時，後添加到集合中的元素比較的次數就非常多了。也就是說，如果集合中現在已經有1000個元素，那麼第1001個元素加入集合時，它就要調用1000次equals方法。這顯然會大大降低效率。 於是，Java採用了哈希表的原理。哈希（Hash）實際上是個人名，由於他提出一哈希算法的概念，所以就以他的名字命名了。哈希算法也稱爲散列算法，是將數據依特定算法直接指定到一個地址上。如果詳細講解哈希算法，那需要更多的文章篇幅，我在這裏就不介紹了。初學者可以這樣理解，hashCode方法實際上返回的就是對象存儲的物理地址（實際可能並不是）。
這樣一來，當集合要添加新的元素時，先調用這個元素的hashCode方法，就一下子能定位到它應該放置的物理位置上。如果這個位置上沒有元素，它就可以直接存儲在這個位置上，不用再進行任何比較了；如果這個位置上已經有元素了，就調用它的equals方法與新元素進行比較，相同的話就不存了，不相同就散列其它的地址。所以這裏存在一個衝突解決的問題。這樣一來實際調用equals方法的次數就大大降低了，幾乎只需要一兩次。 所以，Java對於eqauls方法和hashCode方法是這樣規定的：1、如果兩個對象相同，那麼它們的hashCode值一定要相同；2、如果兩個對象的hashCode相同，它們並不一定相同
上面說的對象相同指的是用eqauls方法比較。 你當然可以不按要求去做了，但你會發現，相同的對象可以出現在Set集合中。同時，增加新元素的效率會大大下降。
java中hashcode()和equals()的詳解
1. 首先equals()和hashcode()這兩個方法都是從object類中繼承過來的。
equals()方法在object類中定義如下：
public boolean equals(Object obj) {
return (this == obj);
} 很明顯是對兩個對象的地址值進行的比較（即比較引用是否相同）。但是我們必需清楚，當String 、Math、還有Integer、Double。。。。等這些封裝類在使用equals()方法時，已經覆蓋了object類的equals（）方法。比如在String類中如下：
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
} 很明顯，這是進行的內容比較，而已經不再是地址的比較。依次類推Double、Integer、Math。。。。等等這些類都是重寫了equals()方法的，從而進行的是內容的比較。當然了基本類型是進行值的比較，這個沒有什麼好說的。
我們還應該注意，Java語言對equals()的要求如下，這些要求是必須遵循的：
• 對稱性：如果x.equals(y)返回是“true”，那麼y.equals(x)也應該返回是“true”。
• 反射性：x.equals(x)必須返回是“true”。
• 類推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那麼z.equals(x)也應該返回是“true”。
• 還有一致性：如果x.equals(y)返回是“true”，只要x和y內容一直不變，不管你重複x.equals(y)多少次，返回都是“true”。
• 任何情況下，x.equals(null)，永遠返回是“false”；x.equals(和x不同類型的對象)永遠返回是“false”。
以上這五點是重寫equals()方法時，必須遵守的準則，如果違反會出現意想不到的結果，請大家一定要遵守。
2. 其次是hashcode() 方法，在object類中定義如下：
public native int hashCode(); public int hashCode() {
int h = hash;
if (h == 0) {
int off = offset;
char val[] = value;
int len = count;
for (int i = 0; i < len; i++) {
h = 31*h + val[off++];
}
hash = h;
}
return h;
} s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
使用 int 算法，這裏 s[i] 是字符串的第 i 個字符，n 是字符串的長度，^ 表示求冪。（空字符串的哈希碼爲 0。）
3.這裏我們首先要明白一個問題：
equals()相等的兩個對象，hashcode()一定相等；
equals（）不相等的兩個對象，卻並不能證明他們的hashcode()不相等。換句話說，equals()方法不相等的兩個對象，hashcode()有可能相等。（我的理解是由於哈希碼在生成的時候產生衝突造成的）。
反過來：hashcode()不等，一定能推出equals()也不等；hashcode()相等，equals()可能相等，也可能不等。解釋下第3點的使用範圍，我的理解是在object、String等類中都能使用。在object類中，hashcode()方法是本地方法，返回的是對象的地址值，而object類中的equals()方法比較的也是兩個對象的地址值，如果equals()相等，說明兩個對象地址值也相等，當然hashcode()也就相等了；在String類中，equals()返回的是兩個對象內容的比較，當兩個對象內容相等時，
Hashcode()方法根據String類的重寫（第2點裏面已經分析了）代碼的分析，也可知道hashcode()返回結果也會相等。以此類推，可以知道Integer、Double等封裝類中經過重寫的equals()和hashcode()方法也同樣適合於這個原則。當然沒有經過重寫的類，在繼承了object類的equals()和hashcode()方法後，也會遵守這個原則。
4.談到hashcode()和equals()就不能不說到hashset,hashmap,hashtable中的使用，具體是怎樣呢，請看如下分析：
Hashset是繼承Set接口，Set接口又實現Collection接口，這是層次關係。那麼hashset是根據什麼原理來存取對象的呢？
在hashset中不允許出現重複對象，元素的位置也是不確定的。在hashset中又是怎樣判定元素是否重複的呢？這就是問題的關鍵所在，經過一下午的查詢求證終於獲得了一點啓示，和大家分享一下，在java的集合中，判斷兩個對象是否相等的規則是：
1)，判斷兩個對象的hashCode是否相等
如果不相等，認爲兩個對象也不相等，完畢
如果相等，轉入2)
（這一點只是爲了提高存儲效率而要求的，其實理論上沒有也可以，但如果沒有，實際使用時效率會大大降低，所以我們這裏將其做爲必需的。後面會重點講到這個問題。）
2)，判斷兩個對象用equals運算是否相等
如果不相等，認爲兩個對象也不相等
如果相等，認爲兩個對象相等（equals()是判斷兩個對象是否相等的關鍵）
爲什麼是兩條準則，難道用第一條不行嗎？不行，因爲前面已經說了，hashcode()相等時，equals()方法也可能不等，所以必須用第2條準則進行限制，才能保證加入的爲非重複元素。
比如下面的代碼：
public static void main(String args[]){
String s1=new String("zhaoxudong");
String s2=new String("zhaoxudong");
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
System.out.println(s1.hashCode());//s1.hashcode()等於s2.hashcode()
System.out.println(s2.hashCode());
Set hashset=new HashSet();
hashset.add(s1);
hashset.add(s2);
/*實質上在添加s1,s2時，運用上面說到的兩點準則，可以知道hashset認爲s1和s2是相等的，是在添加重複元素，所以讓s2覆蓋了s1;*/
Iterator it=hashset.iterator();
while(it.hasNext())
{
System.out.println(it.next());
} 最後在while循環的時候只打印出了一個”zhaoxudong”。
輸出結果爲：
false
true
-967303459
-967303459
這是因爲String類已經重寫了equals()方法和hashcode()方法，所以在根據上面的第1.2條原則判定時，hashset認爲它們是相等的對象，進行了重複添加。
但是看下面的程序：
import java.util.*;
public class HashSetTest
{
public static void main(String[] args)
{
HashSet hs=new HashSet();
hs.add(new Student(1,"zhangsan"));
hs.add(new Student(2,"lisi"));
hs.add(new Student(3,"wangwu"));
hs.add(new Student(1,"zhangsan"));
Iterator it=hs.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class Student
{
int num;
String name;
Student(int num,String name)
{
this.num=num;
this.name=name;
}
public String toString()
{
return num+":"+name;
}
} 輸出結果爲：
1:zhangsan
1:zhangsan
3:wangwu
2:lisi
問題出現了，爲什麼hashset添加了相等的元素呢，這是不是和hashset的原則違背了呢？回答是：沒有
因爲在根據hashcode()對兩次建立的new Student(1,"zhangsan")對象進行比較時，生成的是不同的哈希碼值，所以hashset把他當作不同的對象對待了，當然此時的equals()方法返回的值也不等（這個不用解釋了吧）。那麼爲什麼會生成不同的哈希碼值呢？上面我們在比較s1和s2的時候不是生成了同樣的哈希碼嗎？原因就在於我們自己寫的Student類並沒有重新自己的hashcode()和equals()方法，所以在比較時，是繼承的object類中的hashcode()方法，呵呵，各位還記得object類中的hashcode()方法比較的是什麼吧！！
它是一個本地方法，比較的是對象的地址（引用地址），使用new方法創建對象，兩次生成的當然是不同的對象了（這個大家都能理解吧。。。），造成的結果就是兩個對象的hashcode()返回的值不一樣。所以根據第一個準則，hashset會把它們當作不同的對象對待，自然也用不着第二個準則進行判定了。那麼怎麼解決這個問題呢？？
答案是：在Student類中重新hashcode()和equals()方法。
例如：
class Student
{
int num;
String name;
Student(int num,String name)
{
this.num=num;
this.name=name;
}
public int hashCode()
{
return num*name.hashCode();
}
public boolean equals(Object o)
{
Student s=(Student)o;
return num==s.num && name.equals(s.name);
}
public String toString()
{
return num+":"+name;
}
} 根據重寫的方法，即便兩次調用了new Student(1,"zhangsan")，我們在獲得對象的哈希碼時，根據重寫的方法hashcode()，獲得的哈希碼肯定是一樣的（這一點應該沒有疑問吧）。
當然根據equals()方法我們也可判斷是相同的。所以在向hashset集合中添加時把它們當作重複元素看待了。所以運行修改後的程序時，我們會發現運行結果是：
1:zhangsan
3:wangwu
2:lisi
可以看到重複元素的問題已經消除。
關於在hibernate的pojo類中，重新equals()和hashcode()的問題：
1)，重點是equals，重寫hashCode只是技術要求（爲了提高效率）
2)，爲什麼要重寫equals呢，因爲在java的集合框架中，是通過equals來判斷兩個對象是否相等的
3)，在hibernate中，經常使用set集合來保存相關對象，而set集合是不允許重複的。我們再來談談前面提到在向hashset集合中添加元素時,怎樣判斷對象是否相同的準則，前面說了兩條，其實只要重寫equals()這一條也可以。
但當hashset中元素比較多時，或者是重寫的equals()方法比較複雜時，我們只用equals()方法進行比較判斷，效率也會非常低，所以引入了hashcode()這個方法，只是爲了提高效率，但是我覺得這是非常有必要的（所以我們在前面以兩條準則來進行hashset的元素是否重複的判斷）。
比如可以這樣寫：
public int hashCode(){
return 1;}//等價於hashcode無效 我有一個問題，如果像前面提到的在hashset中判斷元素是否重複的必要方法是equals()方法（根據網上找到的觀點），但是這裏並沒有涉及到關於哈希表的問題，可是這個集合卻叫hashset，這是爲什麼？？
我想，在hashmap,hashtable中的存儲操作，依然遵守上面的準則。所以這裏不再多說。這些是今天看書，網上查詢資料，自己總結出來的，部分代碼和語言是引述，但是千真萬確是自己總結出來的。有錯誤之處和不詳細不清楚的地方還請大家指出，我也是初學者，所以難免會有錯誤的地方，希望大家共同討論。
1. '=='是用來比較兩個變量（基本類型和對象類型）的值是否相等的， 如果兩個變量是基本類型的，那很容易，直接比較值就可以了。如果兩個變量是對象類型的，那麼它還是比較值，只是它比較的是這兩個對象在棧中的引用（即地址）。
對象是放在堆中的，棧中存放的是對象的引用（地址）。由此可見'=='是對棧中的值進行比較的。如果要比較堆中對象的內容是否相同，那麼就要重寫equals方法了。
2. Object類中的equals方法就是用'=='來比較的，所以如果沒有重寫equals方法，equals和==是等價的。
通常我們會重寫equals方法，讓equals比較兩個對象的內容，而不是比較對象的引用（地址）因爲往往我們覺得比較對象的內容是否相同比比較對象的引用（地址）更有意義。
3. Object類中的hashCode是返回對象在內存中地址轉換成的一個int值（可以就當做地址看）。所以如果沒有重寫hashCode方法，任何對象的hashCode都是不相等的。通常在集合類的時候需要重寫hashCode方法和equals方法，因爲如果需要給集合類（比如：HashSet）添加對象，那麼在添加之前需要查看給集合裏是否已經有了該對象，比較好的方式就是用hashCode。
4. 注意的是String、Integer、Boolean、Double等這些類都重寫了equals和hashCode方法，這兩個方法是根據對象的內容來比較和計算hashCode的。（詳細可以查看jdk下的String.java源代碼），所以只要對象的基本類型值相同，那麼hashcode就一定相同。
5. equals()相等的兩個對象，hashcode()一般是相等的，最好在重寫equals()方法時，重寫hashcode()方法； equals()不相等的兩個對象，卻並不能證明他們的hashcode()不相等。換句話說，equals()方法不相等的兩個對象，hashcode()有可能相等。 反過來：hashcode()不等，一定能推出equals()也不等；hashcode()相等，equals()可能相等，也可能不等。在object類中，hashcode()方法是本地方法，返回的是對象的引用（地址值），而object類中的equals()方法比較的也是兩個對象的引用（地址值），如果equals()相等，說明兩個對象地址值也相等，當然hashcode()也就相等了。
以下是測試代碼。
Java代碼
public class Equals_HashCode {
public static void main(String[] args) {
String a = new String("str");
String b = new String("str");
System.out.println(a==b);
System.out.println(a.equals(b));
System.out.println(a.hashCode());
System.out.println(b.hashCode());
// 輸出 false true 114225 114225
class A{
String str;
int i;
public A(String str, int i) {
super();
this.str = str;
this.i = i;
}
}
A aA = new A("str",1);
A bA = new A("str",1);
System.out.println(aA==bA);
System.out.println(aA.equals(bA));
System.out.println(aA.hashCode());
System.out.println(bA.hashCode());
// 輸出 false false 6413875 21174459
class B{
String str;
public B(String str){
this.str = str;
}
}
B aB = new B("str");
B bB = new B("str");
System.out.println(aB==bB);
System.out.println(aB.equals(bB));
System.out.println(aB.hashCode());
System.out.println(bB.hashCode());
// 輸出 false false 827574 17510567
class C{
int i;
public C(int i){
this.i = i;
}
}
C aC = new C(1);
C bC = new C(1);
System.out.println(aC==bC);
System.out.println(aC.equals(bC));
System.out.println(aC.hashCode());
System.out.println(bC.hashCode());
//輸出 false false 27744459 28737396
}
}
java中equals方法和“==”的區別：
equals 方法是 java.lang.Object 類的方法。
有兩種用法說明：
（1）對於字符串變量來說，使用“==”和“equals()”方法比較字符串時，其比較方法不同。
“==”比較兩個變量本身的值，即兩個對象在內存中的首地址。
“equals()”比較字符串中所包含的內容是否相同。
比如：
String s1,s2,s3 = "abc", s4 ="abc" ;
s1 = new String("abc");
s2 = new String("abc"); s1==s2 是 false //兩個變量的內存地址不一樣，也就是說它們指向的對象不 一樣，
故不相等。
s1.equals(s2) 是 true //兩個變量的所包含的內容是abc，故相等。
注意（1）：
如果： StringBuffer s1 = new StringBuffer("a");
StringBuffer s2 = new StringBuffer("a");
結果： s1.equals(s2) //是false
解釋：StringBuffer類中沒有重新定義equals這個方法，因此這個方法就來自Object類，
而Object類中的equals方法是用來比較“地址”的，所以等於false.
注意（2）：
對於s3和s4來說，有一點不一樣要引起注意，由於s3和s4是兩個字符
串常量所生成的變量，其中所存放的內存地址是相等的，
所以s3==s4是true（即使沒有s3=s4這樣一個賦值語句）
（2）對於非字符串變量來說，"=="和"equals"方法的作用是相同的都是用來比較其
對象在堆內存的首地址，即用來比較兩個引用變量是否指向同一個對象。
比如：
class A
{
A obj1 = new A();
A obj2 = new A();
} 那麼：obj1==obj2是false
obj1.equals(obj2)是false
但是如加上這樣一句：obj1=obj2;
那麼 obj1==obj2 是true
obj1.equals(obj2) 是true
總之：equals方法對於字符串來說是比較內容的，而對於非字符串來說是比較
其指向的對象是否相同的。
== 比較符也是比較指向的對象是否相同的也就是對象在對內存中的的首地址。
String類中重新定義了equals這個方法，而且比較的是值，而不是地址。所以是true。
關於equals與==的區別從以下幾個方面來說：
（1）如果是基本類型比較，那麼只能用==來比較，不能用equals
比如：
public class TestEquals {
public static void main(String[] args)
{
int a = 3;
int b = 4;
int c = 3;
System.out.println(a == b);//結果是false
System.out.println(a == c);//結果是true
System.out.println(a.equals(c));//錯誤，編譯不能通過，equals方法
//不能運用與基本類型的比較
}
} （2）對於基本類型的包裝類型，比如Boolean、Character、Byte、Shot、Integer、Long、Float、Double等的引用變量，==是比較地址的，而equals是比較內容的。比如：
public class TestEquals {
public static void main(String[] args)
{ Integer n1 = new Integer(30);
Integer n2 = new Integer(30);
Integer n3 = new Integer(31);
System.out.println(n1 == n2);//結果是false 兩個不同的Integer對象，故其地址不同，
System.out.println(n1 == n3);//那麼不管是new Integer(30)還是new Integer(31) 結果都顯示false
System.out.println(n1.equals(n2));//結果是true 根據jdk文檔中的說明，n1與n2指向的對象中的內容是相等的，都是30，故equals比較後結果是true
System.out.println(n1.equals(n3));//結果是false 因對象內容不一樣，一個是30一個是31
}
}
這是Integer的實例，如果是其他的比如Double、Character、Float等也一樣。
（3）注意：對於String(字符串)、StringBuffer(線程安全的可變字符序列)、StringBuilder(可變字符序列)這三個類作進一步的說明。
（a）首先，介紹String的用法，請看下面的實例：
public class TestEquals {
public static void main(String[] args) {
String s1 = "123";
String s2 = "123";
String s3 = "abc";
String s4 = new String("123");
String s5 = new String("123");
String s6 = new String("abc");
System.out.println(s1 == s2);//（1）true
System.out.println(s1.equals(s2));//（2）true
System.out.println(s1 == s3);//（3）flase
System.out.println(s1.equals(s3));//（4）flase
System.out.println(s4 == s5);//（5）flase
System.out.println(s4.equals(s5));//（6）true
System.out.println(s4 == s6);//（7）flase
System.out.println(s4.equals(s6));//（8）flase
System.out.println(s1 == s4);//（9）false
System.out.println(s1.equals(s4));//（10）true
}
}
答案解釋：s1與s2分別指向由字符串常量”123” 創建的對象，在常量池中，只有一個對象，內容爲123，有兩個引用s1和s2指向這個對象，故這兩個引用變量所指向的地址是相同的，因而（1）處的運行結果爲true，又因爲s1.equals(s2)是比較s1和s2所指向的對象的內容是否相等，而我們知道這兩個對象的內容都是字符串常量”123”，故標記（2）處的運行結果是true。
用同樣的方法分析，s1和s3所指向的對象不一樣，內容也不一樣，故標記（3）和（4）處運行結果是false。
再看看s4和s5，這兩個引用變量所指向的對象的內容都是一樣的（內容都是123），但是這兩個對象是用new操作符創建處類的，是在內存中分配兩塊空間給這兩個對象的，因而這兩個對象的內存地址不一樣，故事兩個不同的對象，標記（5）處的s4 == s5 運行結果爲false，但是內容一樣，故標記（6）處的s4.equals(s5)運行結果爲true。同理，s4和s6所指向的對象地址不同，內容也不相同。故標記（7）（8）處運行結果爲false。
s1和s4分別指向兩個不同的對象（之所以這樣稱呼，是因爲這兩個對象在內存中的地址不相同，故而對象不相同），故標記爲（9）處的s1 == s4運行結果爲false，而標記爲（10）處的s1.equals(s4)運行結果疑問：乍一看結果，有點驚訝，爲什麼不是true呢，不是說 equals方法是比較內容的嗎？
解釋：不錯，如果在新類中被覆蓋了equals方法，就可以用來比較內容的。但是在上面的例子中類Value並沒有覆蓋Object中的equals方法，而是繼承了該方法，因此它就是被用來比較地址的，又v1和v2的所指向的對象不相同，故標記（1）處的v1.equals(v2)運行結果爲false，標記爲（2）處的v1 == v2運行結果也爲false。
——————————————————————————————————————————————
DONE，文章有點多，不過講的很詳細。
