結論：

1.     對於基本資料型別，==比較的是值，equals方法不能使用

2.     對於String和包裝類，==比較的是地址，equals方法比較的是值

3.     對於繼承Object的類，==比較的是地址，equals比較的也是地址

1.基本資料型別

==比較的是值

equals()是不能使用的（因為eauqls()是Object類的方法，物件才能呼叫）

例：

int a=100; 

int b=100; 

System.out.println("a=b"+(a==b));//true 

System.out.println("a.equals(b)"+a.equals.(b));//

2.String和包裝類

==比較的是記憶體中存放的地址

equals()比較的是值，因為它們重寫了Object的equals()方法（類似還有Math，Date等值型別的類）

String部分

例如

String s1="hello"; 

String s2="hello";        

String s3=new String("hello"); 

String s4=new String("hello");   

String s5 = s3; 

String s6 = new String(s3);       

System.out.println("s1=s2"

System.out.println("s1=hello"+(s1=="hello")); 

System.out.println("s3=s4"+(s3==s4)); 

System.out.println("s5=s3"+(s5==s3)); 

System.out.println("s3=s1"+(s3==s1)); 

System.out.println("s5=hello"+(s5 =="hello")); 

System.out.println("s6=hello"+(s6 =="hello")); 

System.out.println(s1.equals(s2)); 

System.out.println(s3.equals(s1)); 

System.out.println(s3.equals(s4)); 

輸出結果：

s1=s2 true

s1=hello true

s3=s4 false

s5=s3 true

s3=s1 false

s5=hello false

s6=hello false

true

true

true

是不是覺得一臉懵逼，摸不著頭腦？

看了下面string兩種賦值方法你一定會茅塞頓開

要知道String的兩種賦值方法：

① " "直接賦值法

② new關鍵字法

第一種直接賦值法Jvm會先去常量池中檢測該字串是否存在，若存在不建立直接地址指向，共享此字串，否則建立新的字串，類似Integer的自動裝箱，

第二種new建立的會直接在堆中開闢記憶體空間

所以s2和s1都指向常量池中hello字串

而s3和s4分別在堆中開闢了記憶體，分別指向不同地址

s3==s1前者記憶體為堆後者為常量池，自然有s3==s1為false

包裝類部分

注意Integer的享元模式：-128~127之間的數值在自動裝箱的過程中，如果記憶體中存在相同數值的Integer類物件，則會共享此物件

看完下面的部分你就會明白

首先要知道包裝類的自動裝箱和自動拆箱機制

大家一定都見過這個語句Integer i= 5;

在jdk1.5以前，這樣的程式碼是錯誤的，必須要通過Integeri = newInteger(5);這樣的語句實現；而在jdk1.5以後，Java提供了自動裝箱的功能，只需Integer i= 5; JVM會幫我們自動裝箱，即基本資料型別轉為包裝類

相應的，包裝類到基本資料型別的過程就是拆箱；如

Integeri =5；

intj =i;//自動拆箱

底層原始碼：

裝箱過程是通過呼叫包裝器的valueOf方法實現的，而拆箱過程是通過呼叫包裝器的xxxValue方法實現的。（xxx代表對應的基本資料型別）

注意：

Integer i=new Integer(xxx) 不會觸發自動裝箱的過程

Integeri=xxx;才會觸發；

例如

Integer i1= new Integer(100);//手動裝箱

Integer i2= newInteger(100); 

System.out.println("i1=i2" + (i1 == i2));//false 

System.out.println("i1.equals(i2)"+i1.equals(i2));//true 

符合我們的預期，因為i1和i2是不同的物件不同的地址

Integer i1= 200;//自動裝箱

Integer i2= 200; 

System.out.println("i1=i2" + (i1 ==i2));//false 

符合我們的預期，因為i1和i2是不同的物件不同的地址

Integer i1= 100; 

Integer i2= 100; 

System.out.println("i1=i2" + (i1 ==i2));//true 

好奇怪？換個數值結果竟然不一樣？難道i1和i2是同一個物件嗎？

結論:此時的i1和i2指向同一物件，原因是Integer比較特殊，在自動裝箱過程中，對於-128~127的值，它們被裝箱為Integer物件後，會存在記憶體中被重用，始終只存在一個物件，而如果超過-128~127的值，被裝箱後的Integer物件並不會被重用，相當於new一個新的Integer物件

另外包裝類==基本資料型別 比較的也是值

Integer i1= 200; 

Integer i2= 100; 

Integer i3= i2+100;//結果300不在-128~127，自動裝箱時產生新的物件

System.out.println("i1=i2+i0" + (i1 == i3));//false 

int i=200; 

System.out.println("i1=i"+(i1==i));//true 

System.out.println("i1=i2+100"+(i1==i2+100));//true 

因為i2+100運算完得到200，還沒有來得及自動裝箱就和i1進行了比較

包裝類例：

Integer i1= newInteger(100); 

Integer i2= newInteger(100); 

Integer i3= 200; 

Integer i4= 200; 

Integer i5= 100; 

Integer i6= 100; 

System.out.println(i1.equals(i2)); 

System.out.println("i1=i2" + (i1 == i2)); 

System.out.println("i3=i4" + (i3 == i4)); 

System.out.println("i5=i6" + (i5 == i6)); 

System.out.println("i5=i6+0"+(i5==i6+0)); 

輸出結果：

true

i1=i2 false

i3=i4 false

i5=i6 true

i5=i6+0 true

3.繼承Object的類

== 比較的是地址

equals()比較的是地址，沒有重寫Object類中的equals()，比較兩個物件的引用是否相等

例如

Object obj1=new Object();

Object obj2=new Object();

System.out.println(obj1==obj2);

System.out.println(obj1.equals(obj2));

StringBuffer s1=new StringBuffer();

StringBuffer s2=new StringBuffer();

System.out.println(s1==s2);

System.out.println(s1.equals(s2));

輸出結果：

false

false

false

false

equals()和hashcode ()的比較：

當比較大量資料的時候hashcode()比equals()效率高

比如向hashset（不允許重複）集合中有1000個元素，新增新元素的時候

equals：呼叫這個元素的equals()方法，遍歷所有元素依次對比，沒有重複的話新增

hashcode：呼叫這個元素的hashcode()方法，定位到相映的物理位置上

如果沒有元素，它就可以直接儲存在這個位置上，不用再進行任何比較

如果已經有元素了，就呼叫equals方法與新元素進行比較，相同則不存，不相同的話，也就是發生了Hash key相同導致衝突的情況，那麼就在這個Hash key的地方產生一個連結串列，將這些元素串在一起

equal()相等的兩個物件他們的hashCode()肯定相等

hashCode()相等的兩個物件他們的equal()不一定相等，因為可能會發生Hash雜湊值衝突

所以當有大量元素需要進行比較的時候先用hashcode()比較，不相等則兩個元素不等。如果hashcode()相等，再呼叫equals()比較，如果equal()也相同，則表示這兩個元素相同。