之前的時候，感覺==和equals()就那麼點區別，後來才發現，不要小看一個簡簡單單的區別，裡邊學問好大啊，才有了這個念頭

接下來就看下他們之間的區別：

首先呢，比較是時候要知道比較什麼？到底是基本資料型別還是引用型別

==比較：

對於JAVA基本資料型別(byte，short，int，long，float，double ，char，varchar)來說，

==只是用來表示內容是否相等。

對於JAVA（String）來說，是比較所指向物件的地址是否相同。

equals()比較：

注意：equals不能作用於基本資料型別。

如果沒有對equals方法進行重寫，則比較的是引用型別的變數所指向的物件的地址

對於JAVA引用型別（String）來說，是比較值是否相同的

----------------------------原始碼-----------------------------------------

為什麼不能作用基本資料型別呢？為何String 可以使用呢？
給你看下原始碼：
例如Integer中的equals:

 public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue
 
();
        }
        return false;
    }

例如String中的equals:

 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;
    }

也都看到了，原來是String中的equals()方法進行了重寫。

下面我做了一些demo：

String str1 = "aaa";
String str2 = "aaa";
System.out.println(str1 == str2);// true 因為String有常量池
 
String str3 = new String("aaa");
String str4 = new String("aaa");
System.out.println(str3 == str4);// false 可以看出用new的方式是生成不同的物件,比較堆上的
         
String s0="helloworld"; 
String s1="helloworld"; 
String s2="hello"+"world"; 
System.out.println(s0==s1); //true 可以看出s0跟s1是指向同一個物件  
System.out.println(s0==s2); //true 可以看出s0跟s2是指向同一個物件  
         
String st0="helloworld";  
String st1=new String("helloworld");  
String st2="hello" + new String("world");  
System.out.println( st0==st1 ); //false    用new String() 建立的字串不是常量，不能在編譯期就確定
System.out.println( st0==st2 ); //false   st2地址存在堆中，不可能相同
System.out.println( st1==st2 ); //false 
         
         
String stri1="abc";    
String stri2="def";    
String stri3=stri1+stri2; 
System.out.println(stri3=="abcdef"); //false    變數相+是在的堆記憶體中建立
         
String strin0 = "a1";  
String strin1 = "a" + 1;   //這種不是變數，是常量
System.out.println((strin0 == strin1)); //result = true   
 
String strin2 = "atrue";  
String strin3= "a" + "true";  
System.out.println((strin2 == strin3)); //result = true   
 
String strin4 = "a3.4";  
String strin5 = "a" + 3.4;  
System.out.println((strin4 == strin5)); //result = true 
         
         
String string0 = "ab";  
String string1 = "b";  
String string2 = "a" + string1;  
System.out.println((string0 == string2)); //result = false  在字串的"+"連線中，有字串引用存在，而引用的值在程式編譯期是無法確定的
         
         
String test="javalanguagespecification"; 
String test2="java"; 
String test3="language"; 
String test4="specification";     
System.out.println(test == "java" + "language" + "specification");  //true 字串字面量拼接操作是在Java編譯器編譯期間就執行了
System.out.println(test == test2 + test3 + test4);  //false  字串引用的"+"運算是在Java執行期間執行的
         
         
String ss0 = "ab";  
final String ss1 = "b";  
String ss2 = "a" + ss1;      
System.out.println((ss0 == ss2)); //result = true  對於final修飾的變數，它在編譯時被解析為常量值的一個本地拷貝儲存到自己的常量池中或嵌入到它的位元組碼流中。所以此時的"a" + s1和"a" + "b"效果是一樣的
         
String ss10 = "ab";  
final String ss11 = getS1();  
String ss12 = "a" + ss11;        
System.out.println((ss10 == ss12)); //result = false   這裡面雖然將s1用final修飾了，但是由於其賦值是通過方法呼叫返回的，那麼它的值只能在執行期間確定
     
public static String getS1(){
     return "b";    
}           

你們可以看下，看下和你們的預判是否一樣哈

文章來源網路，版權歸作者本人所有，如侵犯到原作者權益，請與我們聯絡刪除或授權事宜
如果有誤，請聯絡作者更改，謝謝，本人微信：void666666