###前言
相信很多讀者關於==和equals懂了又懵，懵了又懂，如此循環，事實上可能是因爲看到的博客文章之類的太多了，長篇大論，加上一段時間的洗禮之後就迷路了。本篇文章再一次理清楚。當然如果覺得本文太囉嗦的話，當然我也考慮到了，因爲我也不喜歡長篇大論囉裏囉嗦比比叨叨胡攪蠻纏的文章，畢竟大家入門java 的時候就知道個大概了，因此記住一句話就好了：**equals本身和 == 沒有區別，對於基本數據都是比較值，對於引用類型，則比較的是所指向的對象的地址！其他類在繼承Object類之後對equals方法重寫，所以表現的是比較裏面的內容！**具體比較的則要看自己是怎麼重寫的。
好了，如果有興趣的就看下文，當然不感興趣的大佬可以點個贊直接走了，不用看了，會了還看個*啊，樓主你個憨憨（皮一下很開心）
1、原生的equals()方法本身與 “ == ”沒有任何區別！
從java語言本質上來講，"=="屬於JAVA語言的運算符，而equals則是根類Object的一個方法。
關於Object類的equals()方法，我們可以看看其源碼
/* * @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);}
是的，equals底層其實就是“ == ”，也就是說，原生的equals()方法本身與 “ == ”沒有任何區別！唯一的區別則是基本類型沒有繼承Object類，所以基本類型沒有equals()方法，也就是說基本類型只能使用“ == ”判斷值是否相等。
既然原生的equals()方法本身與 “ == ”沒有任何區別，那麼我們對運算符 “ == ”的使用有所瞭解即可！
運算符 “ == ”其具體作用是用來比較值是否相等，這裏分兩中情況：
-
1、基本數據類型的變量，則直接比較其存儲的 “值”是否相等；
-
2、引用類型的變量，則比較的是所指向的對象的地址是否相等；
到這裏我們可以初步確認原生的equals()方法本身與 “ == ”沒有任何區別！作用正是如上。
2、equals()方法的重寫
但是重點來了，因爲對於equals()方法我一直在強調原生二字。是的，讓很多初學者疑惑的點就在這裏：equals()方法的重寫！
在JDK中，諸如String、Date等類對equals方法進行了重寫，以String爲例，這裏感興趣的讀者可以一起看看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; }
從源碼中可以看出，首先該方法判斷比較的是所指向的對象地址是否相等，如果相同直接返回true，如果不相同進行下一個if判斷，第二個if判斷大致意思則是比較其存儲的 “值”是否相等，也就是比較內容值！相同就返回true，比如兩個new String對象“AAA”和“AAA”，這裏雖然對象地址不相等，但是內容相等，所以同樣返回true。
這裏我就想給各位出個典型的String例子了：
public static void main(String[] args) { String a = "宜春"; String b = new String("宜春"); String c = b; //注意這裏是引用傳遞，意思是c也指向b指向的內存地址 System.out.println(a == b); //false System.out.println(a == c); //false System.out.println(b == c); //true System.out.println(a.equals(b)); //true System.out.println(a.equals(c)); //true System.out.println(b.equals(c)); //true }
【特別注意：String類型屬於引用類型】
解析：（1）a == b？意思是地址指向的是同一塊地方嗎？很明顯不一樣。
（2）a == c？意思是地址指向的是同一塊地方嗎？很明顯不一樣。
（3）b == c？意思是地址指向的是同一塊地方嗎？很明顯內容一樣，所以爲true。
（4）a.equals( b )？意思是地址指向的內容一樣嘛？一樣。
（4）a.equals( c )？意思是地址指向的內容一樣嘛？一樣。
（4）b.equals( c )？意思是地址指向的內容一樣嘛？一樣。
當然，你可能還是有點疑惑，那麼結合下面這張圖再理解上面的解析，你可能就恍然大悟了
OK。現在能理解嘛？你你你…不用回答，我知道你理解了（理直氣壯）。當然值得注意一點的是String中intern()方法，先看一段程序：
public static void main(String[] args) { String a = "宜春"; String b = new String("宜春"); b=b.intern(); System.out.println(a == b); //true System.out.println(a.equals(b)); //true }
intern方法的意思是檢查字符串池裏是否存在，如果存在了那就直接返回爲true。因此在這裏首先a會在字符串池裏面有一個，然後 b.intern()一看池子裏有了，就不再新建new了，直接把b指向它。
3、爲什麼要重寫equals方法？
不知道大家有沒有想過這個問題。當然答案也是很簡單的，因爲程序員比較字符串一般比較其內容就好了，比較內存地址是不是同一個對象就好像沒啥意義了，重寫equals方法就很方便用來比較字符串的內容了。
其實除了諸如String、Date等類對equals方法進行重寫，我們在實際開發中，我們也常常會根據自己的業務需求重寫equals方法.
舉個栗子：我們的需求就是如果兩個學生對象姓名、身份證號、性別相等，我們認爲兩個學生對象相等，不一定需要學生對象地址相同。
學生A的個人信息（姓名：如花,性別:女，身份證號：123，住址：廣州），學生A對象地址爲0x11， 學生B的個人信息（姓名：如花,性別:女，身份證號：123，住址：深圳），學生A對象地址爲0x12，
這時候如果不重寫Object的equals方法，那麼返回的一定是false不相等，這個時候就需要我們根據自己的需求重寫equals()方法了。具體equals方法的重寫代碼如下：
// 重寫equals方法 @Override public boolean equals(Object obj) { if(!(obj instanceof Student)) { // instanceof 已經處理了obj = null的情況 return false; } Student stuObj = (Student) obj; // 對象地址相等 if (this == stuObj) { return true; } // 如果兩個對象姓名、身份證號碼、性別相等，我們認爲兩個對象相等 if (stuObj.name.equals(this.name) && stuObj.sex.equals(this.sex) && stuObj.IDnumber.equals(this.IDnumber)) { return true; } else { return false; } }
開發中這樣設計，才能符合我們的生活！到這裏我就不信了你還搞不定==和equals！
可是一涉及重寫equals方法的同時又衍生了下面一個問題。
4、重寫equals方法之後要不要重寫hashCode()方法？
當然這個問題要討論，又要長篇大論嗶嗶一大堆了，有空寫一篇這樣的文章吧專門討論討論這個問題，當然園子裏的大佬們也寫了一大堆！可以自行去了解了解。本篇文章簡單聊聊，點到即可。
首先hashCode()方法是Object類的一個方法，源碼如下：
/** * 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<font size="-2"><sup>TM</sup></font> 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()方法返回的就是一個int數值，從方法的名稱上就可以看出，其目的是生成一個hash碼。hash碼的主要用途就是在對對象進行散列的時候作爲key輸入，據此很容易推斷出，我們需要每個對象的hash碼儘可能不同，這樣才能保證散列的存取性能。
事實上，Object類提供的默認實現確實保證每個對象的hash碼不同（在對象的內存地址基礎上經過特定算法返回一個hash碼）。Java採用了哈希表的原理。哈希算法也稱爲散列算法，是將數據依特定算法直接指定到一個地址上。初學者可以這樣理解，hashCode方法實際上返回的就是對象存儲的物理地址（實際上不是）。
想要知道hashCode的作用，必須要先知道Java中的集合。
Java中的集合List的元素是有序的，元素可以重複；Set元素無序，但元素不可重複。這我們都清楚。但是你有沒有想過這樣一個問題：要想保證元素不重複，可兩個元素是否重複應該依據什麼來判斷呢？
每錯這裏就是用Object.equals方法了。但是，如果每增加一個元素就檢查一次，那麼當元素很多時，後添加到集合中的元素比較的次數就非常多了。也就是說，如果集合中現在已經有1000個元素，那麼第1001個元素加入集合時，它就要調用1000次equals方法。這顯然會大大降低效率。
那怎麼解決呢？我們可以在Java集合框架中得到驗證。由於HashSet是基於HashMap來實現的，所以這裏只看HashMap的put方法即可。源碼如下：
public V put(K key, V value) { if (table == EMPTY_TABLE) { inflateTable(threshold); } if (key == null) return putForNullKey(value); int hash = hash(key); //這裏通過哈希值定位到對象的大概存儲位置 int i = indexFor(hash, table.length); for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; //if語句中，先比較hashcode，再調用equals()比較 //由於“&&”具有短路的功能，只要hashcode不同，也無需再調用equals方法 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } modCount++; addEntry(hash, key, value, i); return null;}
正如源碼中註釋所述，“&&”具有短路的功能，只要hashcode不同，也無需再調用equals方法。是的，Java採用了哈希表的原理。 哈希表具有優越的查詢性能，就像九九乘法表2*3=6你能很輕易知道，但是哈希表難免還會出現哈希衝突,只是概率極低。
如此設計，這樣一來，當集合要添加新的元素時，先調用這個元素的hashCode方法，就一下子能定位到它應該放置的物理位置上。如果這個位置上沒有元素，它就可以直接存儲在這個位置上，不用再進行任何比較了；如果這個位置上已經有元素了，就調用它的equals方法與新元素進行比較，相同的話就不存，不相同就散列其它的地址。所以這裏存在一個衝突解決的問題。這樣一來實際調用equals方法的次數就大大降低了，幾乎只需要一兩次。
**因此並不是重寫了equals方法就一定要重寫hashCode方法，只有用到HashMap,HashSet等Java集合的時候重寫了equals方法就一定要重寫hashCode方法。**用不到哈希表僅僅重寫equals()方法也OK的。
Java官方建議 重寫equals()就一定要重寫hashCode()方法。畢竟實際開發場景中常常用到Java集合
5、eqauls方法和hashCode方法關係
Java對於eqauls方法和hashCode方法是這樣規定的：
1、如果兩個對象equals爲true ，他們的hashcode一定相等。2、如果兩個對象equals爲false，他們的hashcode有可能相等。3、如果兩個對象hashcode相等，equals不一定爲true。4、如果兩個對象hashcode不相等，equals一定爲false。
最後，若有不足或者不正之處，歡迎指正批評，感激不盡！