1. 先從一道面試題說起

請問下面的

public class Demo {
    public static void main(String args[]){
        String a = "a" + "b" + 1;
        String b = "ab1";
        System.out.println(a == b);
    }
}

要了解這個問題，需要回答下面的幾個問題：

1. 關於“ ==”是做什麼的？
2. equals 呢？
3. a和b在記憶體中是什麼樣的？
4. 編譯時優化方案。

2. 關於==

在Java語言中，“==”就是對比兩個記憶體單元的內容是否一樣。
如果是原始型別byte，boolean，short，char，int，long，float，double，就是直接比較它們的值。
如果是引用，比較的就是引用的值，“引用的值”可以被認為物件的邏輯地址。如果兩個引用發生“==”操作，就是比較相應的兩個物件的地址值是否一樣。換句話說，如果兩個引用所儲存的物件是同一個物件，則返回true，否則返回false（如果引用指向的是null，其實這也是一個jvm賦予給它的某個指定的值）。
看下面的程式碼：

public class Demo {
    public static void main(String args[]){
        List<String> a = null;
        List<String> b = null;
        System.out.println(a == b);
    }
}
  // 輸出結果
  true
  

3. 關於“equals()”方法

“equals()”方法，首先是在Object類中被定義的，它的定義中就是使用“==”方式來匹配的。

//equals在Object類中的原始碼
public boolean equals(Object obj) {
    return (this == obj);
}
 

也就是說，如果不去重寫equals()方法，並且對應的類其父類中沒有重寫過equals()方法，那麼預設的equals()操作就是對比物件的地址。

equals()方法之所以存在，是希望子類去重寫這個方法，實現對比值的功能。

3. a和b在記憶體中是什麼樣的？

a和b在記憶體中是指向同一塊記憶體空間的。這就得益於Java的編譯時優化方案。

我們用反編譯軟體jd-gui看看編譯後的程式碼是怎麼樣的？

import java.io.PrintStream;

public class Demo
{
  public static void main(String[] args)
  {
    String a = "ab1";
    String b = "ab1";
    System.out.println(a == b);
  }
}
 

看到這裡結果應該就一目瞭然了。JVM會把常量疊加在編譯時進行優化，因為常量疊加得到的是固定的值，無須執行時再進行計算，所以會這樣優化。

看到這裡彆著急，JVM只會優化它可以幫你優化的部分，它並不是對所有的內容都可以優化。例如，就拿上面疊加字串來說，如果幾個字串疊加出現了變數，即在編譯時還不確定具體的值是多少，那麼JVM是不會去做這樣的編譯時合併的。

如果上面的這段話你理解了，我們再來看一個例子：

public class Demo {
    public static void main(String args[]){
        String a = "a";
        final String c ="a";

        String b = a + "b";
        String d = c + "b";
        String e = getA() + "b";
        String compare = "ab";

        System.out.println( b == compare);
        System.out.println( d == compare);
        System.out.println( e == compare);
    }
    
    private static String getA(){
        return "a";
    }
}
//輸出結果：
false
true
false

根據我們上面的解釋，判斷b==compare和e==compare輸出結果為false，這個比較容易理解，因為a和getA()並不是一個常量，編譯時並不會對此進行優化，我們用jd-gui可靠編譯後的程式碼：

import java.io.PrintStream;

public class Demo
{
  public static void main(String[] args)
  {
    String a = "a";
    String c = "a";
    
    String b = a + "b";
    String d = "ab";
    String e = getA() + "b";
    String compare = "ab";
    
    System.out.println(b == compare);
    System.out.println(d == compare);
    System.out.println(e == compare);
  }
  
  private static String getA()
  {
    return "a";
  }
}

從編譯後的程式碼，我們可以驗證我們的結論，b和e並沒有被JVM優化。

比較奇怪的是變數d，被JVM優化了。區別在於對疊加的變數c有一個final修飾符。從定義上強制約束了c是不允許被改變的，由於final不可變，所以編譯器自然認為結果是不可變的。

4. 記憶體中的字串（詳細解釋）

字串物件內部是用字元陣列儲存的，那麼看下面的例子：

String m = "hello,world";
String n = "hello,world";
String u = new String(m);
String v = new String("hello,world");

這些語句會發生什麼事情？大概是這樣的：

1. 會分配一個11長度的char陣列，並在常量池分配一個由這個char陣列組成的字串，然後由m去引用這個字串。
2. 用n去引用常量池裡邊的字串，所以和m引用的是同一個物件
3. 生成一個新的字串，單內部的字元陣列引用著m內部的字元陣列。
4. 同樣會生成一個新的字串，但內部的字元陣列引用常量池裡邊的字串內部的字元陣列，意思是和u是同樣的字元陣列。

我們使用圖來表示的話，情況就大概是這樣的：

結論就是，m和n是同一個物件，但m，u，v都是不同的物件，但都使用了同樣的字元陣列，並且用equal判斷的話也會返回true。

我們可以使用反射修改字元陣列來驗證一下效果：

public class Demo {
    public static void main(String args[]) throws NoSuchFieldException, IllegalAccessException {
        String m = "hello,world";
        String n = "hello,world";
        String u = new String(m);
        String v = new String("hello,world");
        Field f = m.getClass().getDeclaredField("value");
        f.setAccessible(true);
        char[] cs = (char[]) f.get(m);
        cs[0] = 'H';
        String p = "Hello,world";
        System.out.println(m.equals(p));
        System.out.println(n.equals(p));
        System.out.println(u.equals(p));
        System.out.println(v.equals(p));
    }
}
//輸出結果：
true
true
true
true

從上面的例子可以看到，經常說的字串是不可變的，其實和其他final類沒有什麼區別，還是引用不可變的意思。雖然String類不開放value，但同樣是可以通過反射進行修改。

5. 關於String中的intern方法

public class Demo {
    public static void main(String args[]){
        String a = "a";
        String b = a + "b";
        String c = "ab";
        String d = new String(b);
        System.out.println(b == c);
        System.out.println(c == d);
        System.out.println(c == d.intern());
        System.out.println(b.intern() == d.intern());
    }
}
//輸出結果
false
false
true
true

String引用所指向的物件，它們儲存在常量池中，同一個值的字串保證全域性唯一。

如何保證全域性唯一呢？ 當呼叫intern()方法時，JVM會在這個常量池中通過equals()方法查詢是否存在等值的String，如果存在，則直接返回常量池中這個String物件的地址；若沒有找到，則會建立等值的字串，然後再返回這個新建立空間的地址。只要是同樣的字串，當呼叫intern()方法時，都會得到常量池中對應String的引用，所以兩個字串通過intern()操作後用等號是可以匹配的。