equals與 hashCode區別，此次終於懂了！
第1部分 equals() 的做用html
equals() 的做用是 用來判斷兩個對象是否相等。java
equals() 定義在JDK的Object.java中。經過判斷兩個對象的地址是否相等(即，是不是同一個對象)來區分它們是否相等。源碼以下：數組
public boolean equals(Object obj) {
return (this == obj);
}
既然Object.java中定義了equals()方法，這就意味着全部的Java類都實現了equals()方法，全部的類均可以經過equals()去比較兩個對象是否相等。 可是，咱們已經說過，使用默認的「equals()」方法，等價於「==」方法。所以，咱們一般會重寫equals()方法：若兩個對象的內容相等，則equals()方法返回true；不然，返回fasle。 數據結構
下面根據「類是否覆蓋equals()方法」，將它分爲2類。
(01) 若某個類沒有覆蓋equals()方法，當它的經過equals()比較兩個對象時，其實是比較兩個對象是否是同一個對象。這時，等價於經過「==」去比較這兩個對象。
(02) 咱們能夠覆蓋類的equals()方法，來讓equals()經過其它方式比較兩個對象是否相等。一般的作法是：若兩個對象的內容相等，則equals()方法返回true；不然，返回fasle。ide
下面，舉例對上面的2種狀況進行說明。函數
1. 「沒有覆蓋equals()方法」的狀況學習
代碼以下 (EqualsTest1.java)：this
import java.util.*;
import java.lang.Comparable;
public class EqualsTest1{
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));
}
/**
* @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;
}
}
}
運行結果：code
false
結果分析：orm
咱們經過 p1.equals(p2) 來「比較p1和p2是否相等時」。實際上，調用的Object.java的equals()方法，即調用的 (p1==p2) 。它是比較「p1和p2是不是同一個對象」。
而由 p1 和 p2 的定義可知，它們雖然內容相同；但它們是兩個不一樣的對象！所以，返回結果是false。
2. "覆蓋equals()方法"的狀況
咱們修改上面的EqualsTest1.java：覆蓋equals()方法。
代碼以下 (EqualsTest2.java)：
import java.util.*;
import java.lang.Comparable;
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));
}
/**
* @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;
}
}
}
運行結果：
true
結果分析：
咱們在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(即，認爲這兩個對象相等)。
下面，經過示例比較它們的區別。
代碼以下：
import java.util.*;
import java.lang.Comparable;
public class EqualsTest3{
public static void main(String[] args) {
// 新建2個相同內容的Person對象，
// 再用equals比較它們是否相等
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
System.out.printf("p1.equals(p2) : %s\n", p1.equals(p2));
System.out.printf("p1==p2 : %s\n", p1==p2);
}
/**
* @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==p2 : false
結果分析：
在EqualsTest3.java 中：
(01) p1.equals(p2)
這是判斷p1和p2的內容是否相等。由於Person覆蓋equals()方法，而這個equals()是用來判斷p1和p2的內容是否相等，偏偏p1和p2的內容又相等；所以，返回true。
(02) p1==p2
這是判斷p1和p2是不是同一個對象。因爲它們是各自新建的兩個Person對象；所以，返回false。
第3部分 hashCode() 的做用
hashCode() 的做用是獲取哈希碼，也稱爲散列碼；它其實是返回一個int整數。這個哈希碼的做用是肯定該對象在哈希表中的索引位置。
hashCode() 定義在JDK的Object.java中，這就意味着Java中的任何類都包含有hashCode() 函數。
雖然，每一個Java類都包含hashCode() 函數。可是，僅僅當建立並某個「類的散列表」(關於「散列表」見下面說明)時，該類的hashCode() 纔有用(做用是：肯定該類的每個對象在散列表中的位置；其它狀況下(例如，建立類的單個對象，或者建立類的對象數組等等)，類的hashCode() 沒有做用。
上面的散列表，指的是：Java集合中本質是散列表的類，如HashMap，Hashtable，HashSet。
也就是說：hashCode() 在散列表中才有用，在其它狀況下沒用。在散列表中hashCode() 的做用是獲取對象的散列碼，進而肯定該對象在散列表中的位置。
OK！至此，咱們搞清楚了：hashCode()的做用是獲取散列碼。可是，散列碼是用來幹什麼的呢？爲何散列表須要散列碼呢？要解決這些問題，就須要理解散列表！關於散列表的內容，非三言兩語道的明白；你們能夠經過下面幾篇文章來學習：
爲了能理解後面的內容，這裏簡單的介紹一下散列碼的做用。
咱們都知道，散列表存儲的是鍵值對(key-value)，它的特色是：能根據「鍵」快速的檢索出對應的「值」。這其中就利用到了散列碼！ 散列表的本質是經過數組實現的。當咱們要獲取散列表中的某個「值」時，其實是要獲取數組中的某個位置的元素。而數組的位置，就是經過「鍵」來獲取的；更進一步說，數組的位置，是經過「鍵」對應的散列碼計算獲得的。
下面，咱們以HashSet爲例，來深刻說明hashCode()的做用。
假設，HashSet中已經有1000個元素。當插入第1001個元素時，須要怎麼處理？由於HashSet是Set集合，它容許有重複元素。
「將第1001個元素逐個的和前面1000個元素進行比較」？顯然，這個效率是相等低下的。散列表很好的解決了這個問題，它根據元素的散列碼計算出元素在散列表中的位置，而後將元素插入該位置便可。對於相同的元素，天然是隻保存了一個。
由此可知，若兩個元素相等，它們的散列碼必定相等；但反過來確不必定。在散列表中，
一、若是兩個對象相等，那麼它們的hashCode()值必定要相同；
二、若是兩個對象hashCode()相等，它們並不必定相等。
注意：這是在散列表中的狀況。在非散列表中必定如此！
對「hashCode()的做用」就談這麼多。
第4部分 hashCode() 和 equals() 的關係
接下面，咱們討論另一個話題。網上不少文章將 hashCode() 和 equals 關聯起來，有的講的不透徹，有誤導讀者的嫌疑。在這裏，我本身梳理了一下 「hashCode() 和 equals()的關係」。
咱們以「類的用途」來將「hashCode() 和 equals()的關係」分2種狀況來講明。
1. 第一種 不會建立「類對應的散列表」
這裏所說的「不會建立類對應的散列表」是說：咱們不會在HashSet, Hashtable, HashMap等等這些本質是散列表的數據結構中，用到該類。例如，不會建立該類的HashSet集合。
在這種狀況下，該類的「hashCode() 和 equals() 」沒有半毛錢關係的！
這種狀況下，equals() 用來比較該類的兩個對象是否相等。而hashCode() 則根本沒有任何做用，因此，不用理會hashCode()。
下面，咱們經過示例查看類的兩個對象相等 以及 不等時hashCode()的取值。
源碼以下 (NormalHashCodeTest.java)：
import java.util.*;
import java.lang.Comparable;
public class NormalHashCodeTest{
public static void main(String[] args) {
// 新建2個相同內容的Person對象，
// 再用equals比較它們是否相等
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
Person p3 = new Person("aaa", 200);
System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
System.out.printf("p1.equals(p3) : %s; p1(%d) p3(%d)\n", p1.equals(p3), p1.hashCode(), p3.hashCode());
}
/**
* @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方法
*/
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(1901116749) p1.equals(p3) : false; p1(1169863946) p3(2131949076)
從結果也能夠看出：p1和p2相等的狀況下，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()方法沒有達到咱們想要的效果。
參考代碼 (ConflictHashCodeTest1.java)：
import java.util.*;
import java.lang.Comparable;
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;
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被視爲不相等。
- 1. equals()和hashCode()區別
- 2. hashcode和equals區別
- 3. hashcode（）和equals（）區別
- 4. HashCode與equals的區別與聯繫
- 5. hashCode與equals的作用與區別
- 6. hashCode與equals的區別與聯繫
- 7. hashCode和equals的區別
- 8. hashcode（）和equals（）的區別
- 9. hashcode()和equals()的區別
- 10. java中的equals與「==」、hashcode的區別
- 更多相關文章...
- • BASE原理與最終一致性 - NoSQL教程
- • SQL 別名 - SQL 教程
- • ☆基於Java Instrument的Agent實現
- • Composer 安裝與使用
-
每一个你不满意的现在，都有一个你没有努力的曾经。