別再問我 new 字元串創建了幾個對象了！我來證明給你看！

2020 年 4 月 20 日
筆記
core-java, core-springboot, JAVA, springboot

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

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

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

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

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

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

字元串常量池

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

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

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

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

以上程式的執行結果為：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 的異常，所以把將永久區廢棄而改用元空間了，改為了使用本地記憶體空間，官網解釋詳情：//openjdk.java.net/jeps/122

答案解密

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

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

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

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

技術論證

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

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

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

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."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #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."<init>":(Ljava/lang/String;)V
  #12 = NameAndType        #5:#13         // "<init>":(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."<init>":()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."<init>":(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"

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

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

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

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

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

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

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

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

true
false

擴展知識

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

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

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

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

警告: 文件 ./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."<init>":()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 3、6 可以看出字元串都被編譯器優化成了字元串「abc」了。

總結

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

最後的話
原創不易，本篇近 3000 的文字描述，以及大量精美的圖片，耗費了作者大概 5 個多小時的時間，寫作是一件很酷，並且能幫助他人的事，作者希望一直能堅持下去。如果覺得有用，請隨手點擊一個贊吧，謝謝。

Tags: core-java core-springboot JAVA springboot