public class StringInternTest {
    public static void main(String[] args) {
        String reference1 = new String("a");
        reference1.intern();
        String reference2 = "a";
        System.out.println(reference1 == reference2);

        String reference3 = new String("a") + new String("a");
        reference3.intern();
        String reference4 = "aa";
        System.out.println(reference3 == reference4);
    }
}

    /**
     * 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();

Java_java_lang_String_intern(JNIEnv *env, jobject this)
{
    return JVM_InternString(env, this);
}

/**
 * JDK6 String#intern()執(zhí)行說明
 */
public class StringInternTest {
    public static void main(String[] args) {
        //Step6.1
        //創(chuàng)建了2個對象，分別是堆區(qū)的String對象和字符串常量池中的"a"對象，reference1引用指向在堆區(qū)中的對象地址
        String reference1 = new String("a");
        //Step6.2
        //判斷字符串常量池，是否該字符串"a"，此前，池中已經(jīng)有該對象了，因此會返回池中的對象地址的引用
        reference1.intern();
        //Step6.3
        //字符串常量池中已存在字符串"a"，因此reference2引用直接指向?qū)ο笤谧址Ａ砍刂械牡刂?
        String reference2 = "a";
        //reference1指向?qū)ο蟮刂肥窃诙褏^(qū)，reference2指向?qū)ο蟮刂肥窃谟谰么某Ａ砍兀@然不可能一樣
        System.out.println(reference1 == reference2);

        //Step6.4
        //創(chuàng)建了2個對象，分別是在堆區(qū)的String對象(內(nèi)容是"aa")和字符串常量池中的"a"對象
        //reference3引用指向?qū)ο笤诙褏^(qū)中的地址，這過程還會在堆區(qū)創(chuàng)建了兩個無引用的"a"對象，這里不做討論
        String reference3 = new String("a") + new String("a");
        //Step6.5
        //判斷永久代中的字符串常量池，是否存在該字符串"aa"，這里是首次出現(xiàn)，因此直接將字符串拷貝并放到池中
        reference3.intern();
        //Step6.6
        //池中已存在該字符串，reference2引用直接指向?qū)ο笤谟谰么址Ａ砍刂械牡刂?
        String reference4 = "aa";
        //同樣，reference3指向堆區(qū)地址，reference4指向永久代常量池中的地址，顯然不可能一樣
        System.out.println(reference3 == reference4);
    }
}

/**
 * JDK1.7 String#intern()執(zhí)行說明
 **/
public class StringInternTest {
    public static void main(String[] args) {
        //Step7.1
        //創(chuàng)建了2個對象，分別是堆區(qū)的String對象和字符串常量池中的"a"對象，reference1引用指向在堆區(qū)中的對象地址
        String reference1 = new String("a");
        //Step7.2
        //判斷字符串常量池，是否該字符串"a"，此前，池中已經(jīng)有該對象了，因此會返回池中的對象地址的引用
        reference1.intern();
        //Step7.3
        //字符串常量池中已存在字符串"a"，因此reference2引用直接指向?qū)ο笤谧址Ａ砍刂械牡刂?
        String reference2 = "a";
        //reference1指向?qū)ο蟮刂肥窃诙褏^(qū)，reference2指向?qū)ο蟮刂肥窃诙褏^(qū)的字符串常量池，引用指向的對象地址不一樣
        System.out.println( reference1 == reference2);

        //Step7.4
        //創(chuàng)建了2個對象，分別是在堆區(qū)的String對象(內(nèi)容是"aa")和字符串常量池中的"a"對象（注意并不會創(chuàng)建"aa"對象）
        //reference3引用指向?qū)ο笤诙褏^(qū)中的地址，這過程還會在堆區(qū)創(chuàng)建了兩個無引用的"a"對象，這里不做討論
        String reference3 = new String("a") + new String("a");
        //Step7.5
        //判斷堆區(qū)的字符串常量池中，是否存在該字符串"aa"，顯然這里是首次出現(xiàn)
        //但并不像JDK6會新建對象"aa"存儲，而是存儲指向堆區(qū)已有對象地址的一個新引用
        reference3.intern();
        //Step7.6
        //指向池中已有該字符串的新引用，reference4引用直接指向字符串常量池中的這個新引用，新引用則指向堆區(qū)已有對象地址
        String reference4 = "aa";
        //reference4指向新引用，而新引用則指向堆區(qū)已有對象地址，跟reference3引用直接指向的對象地址是同一個
        System.out.println(reference3 == reference4);
    }

public class com.justin.java.lang.InternTest {
  public com.justin.java.lang.InternTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/StringBuilder
       3: dup
       4: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V
       7: new           #4                  // class java/lang/String
      10: dup
      11: ldc           #5                  // String a
      13: invokespecial #6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
      16: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      19: new           #4                  // class java/lang/String
      22: dup
      23: ldc           #8                  // String b
      25: invokespecial #6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
      28: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      31: invokevirtual #9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      34: astore_1
      35: return
}