JDK8中String的intern()方法詳細解讀【記憶體圖解+多種例子+1.1w字長文】

一、前言

String字串在我們日常開發中最常用的，當然還有他的兩個兄弟StringBuilder和StringBuilder。他三個的區別也是面試中經常問到的，大家如果不知道，就要先去看看了哈！最近也是看周志明老師的深入JVM一書中寫到關於intern()方法的介紹，小編也是以前沒在開發中用到。但是面試題還是很多的，所以特意研究了一天，寫下來記錄一下自己的收穫，希望也可以幫助到大家！！

二、圖文理解String建立物件

1.例子一

String str1 = "wang";

JVM在編譯階段會判斷字串常數池中是否有 "wang" 這個常數物件如果有，str1直接指向這個常數的參照，如果沒有會在常數池裡建立這個常數物件。

2.例子二

String str2 = "學" + "Java";

JVM編譯階段過編譯器優化後會把字串常數直接合併成"學Java"，所有建立物件時只會在常數池中建立1個物件。

3.例子三

String str3 = new String("學Java");

當程式碼執行到括號中的"學Java"的時候會檢測常數池中是否存在"學Java"這個物件，如果不存在則在字串常數池中建立一個物件。當整行程式碼執行完畢時會因為new關鍵字在堆中建立一個"學Java"物件，並把棧中的變數"str3"指向堆中的物件，如下圖所示。這也是為什麼說通過new關鍵字在大部分情況下會建立出兩個字串物件！

4.例子四

String str4 = "學Java";
String str5 = "學Java";
System.out.println(str4 == str5); // 如下圖得知為：true

第一行程式碼：
JVM在編譯階段會判斷字串常數池中是否有 "學Java" 這個常數物件如果有，str4直接指向這個常數的參照，如果沒有會在常數池裡建立這個常數物件。
第二行程式碼：
再建立"學Java"，發現字串常數池中存在了"學Java"，所以直接將棧中的str5變數也指向字串常數池中已存在的"學Java"物件，從而避免重複建立物件，這也是字串常數池存在的原因。

5.例子五

String str6 = new String("學") + new String("Java");

首先，會先判斷字串常數池中是否存在"學"字串物件，如果不存在則在字串常數池中建立一個物件。當執行到new關鍵字在堆中建立一個"學"字串物件。後面的new String("Java")，也是這樣。
然後，當右邊完成時，會在堆中建立一個"學Java"字串物件。並把棧中的變數"str6"指向堆中的物件。
總結：一句程式碼建立了5個物件，但是有兩個在堆中是沒有參照的，按照垃圾回收的可達性分析，他們是垃圾就是"學"、"Java"這倆垃圾。

心得：
上面程式碼進行反編譯：

String str6 = (new StringBuilder()).append(new String("\u5B66"))
					.append(new String("Java")).toString();

底層是一個StringBuilder在進行把兩個物件拼接在一起，最後棧中str6指向堆中的"學Java"，其實是StringBuilder物件。

6.例子六

String str7 = new String("學Java");
String str8 = new String("學Java");
System.out.println(str7 == str8); // 如下圖得知為：false

執行到第一行：
執行到括號內的"學Java"，會先判斷字串常數池中是否存在"學Java"字串物件，如果沒有則在字串常數池中建立一個"學Java"字串物件，執行到new關鍵字時，在堆中建立一個"學Java"字串物件，棧中的變數str7的參照指向堆中的"學Java"字串物件。
執行到第二行：
當執行到第二行括號中的"學Java"時，先判斷常數池中是否有"學Java"字串物件，因為第一行程式碼已經將其建立，所以有的話就不建立了；執行到new關鍵字時，在堆中建立一個"學Java"字串物件，棧中的變數str8的參照指向堆中的"學Java"字串物件。

三、深入理解intern()方法

1. 原始碼檢視

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    // ....
    /**
     * Returns a canonical representation for the string object.
     * <p>
     * A pool of strings, initially empty, is maintained privately by the
     * class {@code String}.
     * <p>
     * When the intern method is invoked, if the pool already contains a
     * string equal to this {@code String} object as determined by
     * the {@link #equals(Object)} method, then the string from the pool is
     * returned. Otherwise, this {@code String} object is added to the
     * pool and a reference to this {@code String} object is returned.
     * <p>
     * It follows that for any two strings {@code s} and {@code t},
     * {@code s.intern() == t.intern()} is {@code true}
     * if and only if {@code s.equals(t)} is {@code true}.
     * <p>
     * All literal strings and string-valued constant expressions are
     * interned. String literals are defined in section 3.10.5 of the
     * <cite>The Java&trade; Language Specification</cite>.
     *
     * @return  a string that has the same contents as this string, but is
     *          guaranteed to be from a pool of unique strings.
     */
    public native String intern();
}

翻譯過來就是，當intern()方法被呼叫的時候，如果字串常數池中已經存在這個字串物件了，就返回常數池中該字串物件的地址；如果字串常數池中不存在，就在常數池中建立一個指向該物件堆中範例的參照，並返回這個參照地址。

2. 例子一

我們直接先把周志明老師的在深入JVM一書的例子：

String str1 = new StringBuilder("計算機").append("軟體").toString(); 
System.out.println(str1.intern() == str1);
String str2 = new StringBuilder("ja").append("va").toString(); 
System.out.println(str2.intern() == str2);

這段程式碼在JDK 6中執行，會得到兩個false，而在JDK 7、8中執行，會得到一個true和一個false。產 生差異的原因是，在JDK 6中，intern()方法會把首次遇到的字串範例複製到永久代的字串常數池 中儲存，返回的也是永久代裡面這個字串範例的參照，而由StringBuilder建立的字串物件範例在 Java堆上，所以必然不可能是同一個參照，結果將返回false。 而JDK 7（以及部分其他虛擬機器器，例如JRockit）的intern()方法實現就不需要再拷貝字串的範例到永久代了，既然字串常數池已經移到Java堆中，那隻需要在常數池裡記錄一下首次出現的範例參照即可，因此intern()返回的參照和由StringBuilder建立的那個字串範例就是同一個。而對str2比較返 回false，這是因為「java」（下面解釋）這個字串在執行String-Builder.toString()之前就已經出現過了，字串常數 池中已經有它的參照，不符合intern()方法要求「首次遇到」的原則，「計算機軟體」這個字串則是首次出現的，因此結果返回true。

java為什麼已經存在了？

1.我們在一個類中輸入System，然後點選到這個方法中，方法內容如下：

public final class System {
	// ...
	private static void initializeSystemClass() {
		// ...
		sun.misc.Version.init();
		// ...
	}
	// ...
}

2.我們點選上面的Version類，類內容如下：

public class Version {
    private static final String launcher_name = "java";
    private static final String java_version = "1.8.0_121";
    private static final String java_runtime_name = "Java(TM) SE Runtime Environment";
    private static final String java_profile_name = "";
    private static final String java_runtime_version = "1.8.0_121-b13";
    private static boolean versionsInitialized;
    private static int jvm_major_version;
    private static int jvm_minor_version;
    private static int jvm_micro_version;
    private static int jvm_update_version;
    private static int jvm_build_number;
    private static String jvm_special_version;
    private static int jdk_major_version;
    private static int jdk_minor_version;
    private static int jdk_micro_version;
    private static int jdk_update_version;
    private static int jdk_build_number;
    private static String jdk_special_version;
    private static boolean jvmVersionInfoAvailable;

    public Version() {
    }

    public static void init() {
        System.setProperty("java.version", "1.8.0_121");
        System.setProperty("java.runtime.version", "1.8.0_121-b13");
        System.setProperty("java.runtime.name", "Java(TM) SE Runtime Environment");
    }
}

3.找到java關鍵字，所以上面的str2.intern() == str2返回false。

private static final String launcher_name = "java";

我們開始例子和詳細解釋，發車了，大家坐好哦！
以下例子來自：原部落格，解釋是為小編自己的理解。

3. 例子二

String str1 = new String("wang");
str1.intern();
String str2 = "wang";
System.out.println(str1 == str2); // false

執行第一行程式碼：
首先執行到"wang"，因為字串常數池中沒有，則會在字串常數池中建立"wang"字串物件。
然後執行到new關鍵字時，在堆中建立一個"wang"的物件，並把棧中的str1的參照指向"wang"物件。

執行第二行程式碼：
這裡我們看到就是str1手動把"wang"放在字串常數池中，但是發現字串常數池中已經存在"wang"字串物件，所以直接把已存在的參照返回。雖然str1.intern()指向了字串常數池中的"wang"，但是我們第四行程式碼並沒有拿str1.intern()作比較，所以還是false。

執行第三行程式碼：
首先通過第一行程式碼，字串常數池中已經有"wang"字串物件了，所以本行程式碼只需要把棧中的str2變數指向字串常數池中的"wang"即可。

執行第四行程式碼：
如上和下圖可見，我們的str1執行堆中的"wang"，str2指向的是字串常數池中的"wang"，肯定返回false。

4. 例子三

String str3 = new String("wang") + new String("zhen");
str3.intern();
String str4 = "wangzhen";
System.out.println(str3 == str4); // true

執行到第一行程式碼：
首先執行到"wang"時，因為字串常數池中沒有，則會在字串常數池中建立一個"wang"字串物件；
然後執行到"zhen"時，因為字串常數池中沒有，則會在字串常數池中建立一個"zhen"字串物件；
最後執行到new關鍵字時，看到是兩個，但是底層位元組碼檔案反編譯的是使用如下可見，只會有一個StringBuilder物件生成，於是將棧中的str3的參照指向堆中的"wangzhen"物件。

String str3 = (new StringBuilder()).append(new String("wang"))
					.append(new String("zhen")).toString();

執行到第二行程式碼：
這裡我們看到就是str3手動把"wangzhen"放在字串常數池中，在字串常數池中沒有找到"wangzhen"，於是把str3 .intern()參照指向堆中的"wangzhen"的地址。現在str3和str3 .intern()一樣

執行到第三行程式碼：
判斷字串常數池中是否存在"wangzhen"字串物件，第二行程式碼已經在字串常數池中建立了"wangzhen"，不過str4是指向str3中堆的參照（看圖就明白了）。

執行到第四行程式碼：
str3和str3 .intern()參照一樣，str3 .intern()和str4是一個，所以str3和str4相等。

5. 例子四

String str5 = new String("wang") + new String("zhen");
String str6 = "wangzhen";
str5.intern();
System.out.println(str5 == str6); // false

執行到第一行程式碼：
首先執行到"wang"時，因為字串常數池中沒有，則會在字串常數池中建立一個"wang"字串物件；
然後執行到"zhen"時，因為字串常數池中沒有，則會在字串常數池中建立一個"zhen"字串物件；
最後執行到new關鍵字時，看到是兩個，但是底層位元組碼檔案反編譯的是使用如下可見，只會有一個StringBuilder物件生成，於是將棧中的str5的參照指向堆中的"wangzhen"物件。同上面的反編譯程式碼

執行到第二行程式碼：
執行到"wangzhen"，判斷字串常數池中是否存在"wangzhen"，發現沒有，在字串常數池中建立"wangzhen"字串物件，然後把棧中的str6變數的參照指向"wangzhen"物件。

執行到第三行程式碼：
這裡我們看到就是str5手動把"wangzhen"放在字串常數池中，我們發現，在字串常數池中已存在"wangzhen"，於是str5 .intern()就是"wangzhen"物件的地址。我們還沒沒有收到返回值

如下圖，我們看到肯定返回false，此時str5.intern() == str6 (true)

6. 例子五

String str7 = new String("wang") + new String("zhen");
String str8 = "wangzhen";
System.out.println(str7.intern() == str8); // true
System.out.println(str7 == str8); // false
System.out.println(str8 == "wangzhen"); // true

執行到第一行程式碼：
同例子三和例子四的第一行程式碼；

執行到第二行程式碼：
先判斷字串常數池中是否存在"wangzhen"物件，發現沒有，我們在字串常數池中建立"wangzhen"字串物件；

執行到第三行程式碼：
執行到str7.intern()這裡，我們看到就是str7手動把"wangzhen"放在字串常數池中，在字串常數池中已結存在"wangzhen"，於是把字串常數池"wangzhen"的地址。現在str7和str7 .intern()一樣

執行到第四行程式碼：
str7的指向為堆中的"wangzhen"，而str8指向則為字串常數池中的"wangzhen"，故不相同，返回false。

執行到第五行程式碼：
str8指向則為字串常數池中的"wangzhen"，執行"wangzhen"，則把已存在的字串常數池中"wangzhen"返回，故相同，返回true。

7. 例子六

String str9 = new String("wang") + new String("zhen");
System.out.println(str9.intern() == str9); // true
System.out.println(str9 == "wangzhen"); // true

執行到第一行程式碼：
同上

執行到第二行程式碼：
執行到str9.intern()這裡，我們看到就是str9手動把"wangzhen"放在字串常數池中，在字串常數池中沒有"wangzhen"，於是把str3 .intern()參照指向堆中的"wangzhen"的地址。現在str9和str9.intern()一樣

執行到第三行程式碼：
str9指向堆記憶體中的"wangzhen"，執行到"wangzhen"時，發現字串常數池中已存在，直接返回str9指向的參照即可，故返回true。

四、總結

經過這麼多例子，大家應該明白了吧，還是要自己跟著例子進行換一下jvm記憶體圖，這樣就理解記憶，也不會輕易忘記！看到這裡了，給小編點個讚唄，整理了一天。太不容易了，謝謝大家了！

在此感謝小編參考的部落格：參考部落格，小編在基礎上按照自己的理解寫的，也進行了深入的擴充套件哈！

---

歡迎大家關注小編的微信公眾號！！謝謝大家！！

有緣人才能看到，自己網站，歡迎存取！！！

點選存取！歡迎存取，裡面也是有很多好的文章哦！