圖文並茂：深入淺出的抓住Java創建字符串的內部機制

作者：老王

連接：https://mp.weixin.qq.com/s/f6VTVXktADP7U1BmlUWM-Q

我想所有 Java 程序員都曾被這個 new String 的問題困擾過，這是一道高頻的 Java 面試題，但可惜的是網上眾說紛紜，竟然找不到標準的答案。有人說創建了 1 個對象，也有人說創建了 2 個對象，還有人說可能創建了 1 個或 2 個對象，但誰都沒有拿出幹掉對方的證據，這就讓我們這幫吃瓜群眾們陷入了兩難之中，不知道到底該信誰的。

但是今天，老王就斗膽和大家聊聊這個話題，順便再拿出點證據。

以目前的情況來看，關於 new String("xxx") 創建對象個數的答案有 3 種：

1. 有人說創建了 1 個對象；
2. 有人說創建了 2 個對象；
3. 有人說創建了 1 個或 2 個對象。

而出現多個答案的關鍵爭議點在「字符串常量池」上，有的說 new 字符串的方式會在常量池創建一個字符串對象，有人說 new 字符串的時候並不會去字符串常量池創建對象，而是在調用 intern() 方法時，才會去字符串常量池檢測並創建字符串。

那我們就先來說說這個「字符串常量池」。

字符串常量池

字符串的分配和其他的對象分配一樣，需要耗費高昂的時間和空間為代價，如果需要大量頻繁的創建字符串，會極大程度地影響程序的性能，因此 JVM 為了提高性能和減少內存開銷引入了字符串常量池（Constant Pool Table）的概念。

字符串常量池相當於給字符串開闢一個常量池空間類似於緩存區，對於直接賦值的字符串（String s="xxx"）來說，在每次創建字符串時優先使用已經存在字符串常量池的字符串，如果字符串常量池沒有相關的字符串，會先在字符串常量池中創建該字符串，然後將引用地址返回變量，如下圖所示：

以上說法可以通過如下代碼進行證明：

<code>public class StringExample {
    public static void main(String[] args) {
        String s1 = "Java";
        String s2 = "Java";
        System.out.println(s1 == s2);
    }
}/<code>

以上程序的執行結果為：true，說明變量 s1 和變量 s2 指向的是同一個地址。

在這裡我們順便說一下字符串常量池的再不同 JDK 版本的變化。

常量池的內存佈局

從JDK 1.7 之後把永生代換成的元空間，把字符串常量池從方法區移到了 Java 堆上。

JDK 1.7 內存佈局如下圖所示：

JDK 1.8 內存佈局如下圖所示：

JDK 1.8 與 JDK 1.7 最大的區別是 JDK 1.8 將永久代取消，並設立了元空間。官方給的說明是由於永久代內存經常不夠用或發生內存洩露，會爆出 java.lang.OutOfMemoryError: PermGen 的異常，所以把將永久區廢棄而改用元空間了，改為了使用本地內存空間，官網解釋詳情：http://openjdk.java.net/jeps/122

答案解密

認為 new 方式創建了 1 個對象的人認為，new String 只是在堆上創建了一個對象，只有在使用 intern() 時才去常量池中查找並創建字符串。

認為 new 方式創建了 2 個對象的人認為，new String 會在堆上創建一個對象，並且在字符串常量池中也創建一個字符串。

認為 new 方式有可能創建 1 個或 2 個對象的人認為，new String 會先去常量池中判斷有沒有此字符串，如果有則只在堆上創建一個字符串並且指向常量池中的字符串，如果常量池中沒有此字符串，則會創建 2 個對象，先在常量池中新建此字符串，然後把此引用返回給堆上的對象，如下圖所示：

老王認為正確的答案：創建 1 個或者 2 個對象。

技術論證

解鈴還須繫鈴人，回到問題的那個爭議點上，new String 到底會不會在常量池中創建字符呢？我們通過反編譯下面這段代碼就可以得出正確的結論，代碼如下：

<code>public class StringExample {
    public static void main(String[] args) {
        String s1 = new String("javaer-wang");
        String s2 = "wang-javaer";
        String s3 = "wang-javaer";
    }
}/<code>

首先我們使用 javac StringExample.java 編譯代碼，然後我們再使用 javap -v StringExample 查看編譯的結果，相關信息如下：

<code>Classfile /Users/admin/github/blog-example/blog-example/src/main/java/com/example/StringExample.class
  Last modified 2020年4月16日; size 401 bytes
  SHA-256 checksum 89833a7365ef2930ac1bc3d7b88dcc5162da4b98996eaac397940d8997c94d8e
  Compiled from "StringExample.java"
public class com.example.StringExample
  minor version: 0
  major version: 58
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #16                         // com/example/StringExample
  super_class: #2                         // java/lang/Object
  interfaces: 0, fields: 0, methods: 2, attributes: 1
Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               
   #6 = Utf8               ()V
   #7 = Class              #8             // java/lang/String
   #8 = Utf8               java/lang/String
   #9 = String             #10            // javaer-wang
  #10 = Utf8               javaer-wang
  #11 = Methodref          #7.#12         // java/lang/String."":(Ljava/lang/String;)V
  #12 = NameAndType        #5:#13         // "":(Ljava/lang/String;)V
  #13 = Utf8               (Ljava/lang/String;)V
  #14 = String             #15            // wang-javaer
  #15 = Utf8               wang-javaer
  #16 = Class              #17            // com/example/StringExample
  #17 = Utf8               com/example/StringExample
  #18 = Utf8               Code
  #19 = Utf8               LineNumberTable
  #20 = Utf8               main
  #21 = Utf8               ([Ljava/lang/String;)V
  #22 = Utf8               SourceFile
  #23 = Utf8               StringExample.java
{
  public com.example.StringExample();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."":()V
         4: return
      LineNumberTable:
        line 3: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=4, args_size=1
         0: new           #7                  // class java/lang/String
         3: dup
         4: ldc           #9                  // String javaer-wang
         6: invokespecial #11                 // Method java/lang/String."":(Ljava/lang/String;)V
         9: astore_1
        10: ldc           #14                 // String wang-javaer
        12: astore_2
        13: ldc           #14                 // String wang-javaer
        15: astore_3
        16: return
      LineNumberTable:
        line 5: 0
        line 6: 10
        line 7: 13
        line 8: 16
}
SourceFile: "StringExample.java"/<code>

備註：以上代碼的運行也編譯環境為 jdk1.8.0_101。

其中 Constant pool 表示字符串常量池，我們在字符串編譯期的字符串常量池中找到了我們String s1 = new String("javaer-wang"); 定義的“javaer-wang”字符，在信息 #10 = Utf8 javaer-wang 可以看出，也就是在編譯期 new 方式創建的字符串就會被放入到編譯期的字符串常量池中，也就是說 new String 的方式會首先去判斷字符串常量池，如果沒有就會新建字符串那麼就會創建 2 個對象，如果已經存在就只會在堆中創建一個對象指向字符串常量池中的字符串。

那麼問題來了，以下這段代碼的執行結果為 true 還是 false？

<code>String s1 = new String("javaer-wang");
String s2 = new String("javaer-wang");
System.out.println(s1 == s2);/<code>

既然 new String 會在常量池中創建字符串，那麼執行的結果就應該是 true 了。其實並不是，這裡對比的變量 s1 和 s2 堆上地址，因為堆上的地址是不同的，所以結果一定是 false，如下圖所示：

從圖中可以看出 s1 和 s2 的引用一定是相同的，而 s3 和 s4 的引用是不同的，對應的程序代碼如下：

<code>public static void main(String[] args) {
    String s1 = "Java";
    String s2 = "Java";
    String s3 = new String("Java");
    String s4 = new String("Java");
    System.out.println(s1 == s2);
    System.out.println(s3 == s4);
}/<code>

程序執行的結果也符合預期：

true

false

擴展知識

我們知道 String 是 final 修飾的，也就是說一定被賦值就不能被修改了。但編譯器除了有字符串常量池的優化之外，還會對編譯期可以確認的字符串進行優化，例如以下代碼：

<code>public static void main(String[] args) {
    String s1 = "abc";
    String s2 = "ab" + "c";
    String s3 = "a" + "b" + "c";
    System.out.println(s1 == s2);
    System.out.println(s1 == s3);
}/<code>

按照 String 不能被修改的思想來看，s2 應該會在字符串常量池創建兩個字符串“ab”和“c”，s3 會創建三個字符串，他們的引用對比結果也一定是 false，但其實不是，他們的結果都是 true，這是編譯器優化的功勞。

同樣我們使用 javac StringExample.java 先編譯代碼，再使用 javap -c StringExample 命令查看編譯的代碼如下：

<code>警告: 文件 ./StringExample.class 不包含類 StringExample
Compiled from "StringExample.java"
public class com.example.StringExample {
  public com.example.StringExample();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #7                  // String abc
       2: astore_1
       3: ldc           #7                  // String abc
       5: astore_2
       6: ldc           #7                  // String abc
       8: astore_3
       9: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      12: aload_1
      13: aload_2
      14: if_acmpne     21
      17: iconst_1
      18: goto          22
      21: iconst_0
      22: invokevirtual #15                 // Method java/io/PrintStream.println:(Z)V
      25: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      28: aload_1
      29: aload_3
      30: if_acmpne     37
      33: iconst_1
      34: goto          38
      37: iconst_0
      38: invokevirtual #15                 // Method java/io/PrintStream.println:(Z)V
      41: return
}/<code>

從 Code 3、6 可以看出字符串都被編譯器優化成了字符串“abc”了。

總結

本文我們通過 javap -v XXX 的方式查看編譯的代碼發現 new String 首次會在字符串常量池中創建此字符串，那也就是說，通過 new 創建字符串的方式可能會創建 1 個或 2 個對象，如果常量池中已經存在此字符串只會在堆上創建一個變量，並指向字符串常量池中的值，如果字符串常量池中沒有相關的字符，會先創建字符串在返回此字符串的引用給堆空間的變量。我們還將了字符串常量池在 JDK 1.7 和 JDK 1.8 的變化以及編譯器對確定字符串的優化，希望能幫你正在的理解字符串的比較。