超過1W字深度剖析JVM常量池（全網最詳細最有深度）

• 2021 年 11 月 7 日
• 筆記

面試題：String a = “ab”; String b = “a” + “b”; a == b 是否相等

面試考察點

考察目的： 考察對JVM基礎知識的理解，涉及到常量池、JVM運行時數據區等。

考察範圍： 工作2到5年。

背景知識

要回答這個問題，需要搞明白兩個最基本的問題

1. String a=「ab」，在JVM中發生了什麼？
2. String b=「a」+「b」，底層是如何實現？

JVM的運行時數據

首先，我們一起來複習一下JVM的運行時數據區。

為了讓大家有一個全局的視角，我從類加載，到JVM運行時數據區的整體結構畫出來，如下圖所示。

對於每一個區域的作用，在我之前的面試系列文章中有詳細說明，這裡就不做複述了。

在上圖中，我們需要重點關注幾個類容：

1. 字符串常量池
2. 封裝類常量池
3. 運行時常量池
4. JIT編譯器

這些內容都和本次面試題有非常大的關聯關係，這裡對於常量池部分的內容，先保留一個疑問，先跟隨我來學習一下JVM中的常量池。

JVM中都有哪些常量池

大家經常會聽到各種常量池，但是又不知道這些常量池到底存儲在哪裡，因此會有很多的疑問：JVM中到底有哪些常量池？

JVM中的常量池可以分成以下幾類：

1. Class文件常量池
2. 全局字符串常量池
3. 運行時常量池

Class文件常量池

每個Class文件的位元組碼中都有一個常量池，裏面主要存放編譯器生成的各種字面量和符號引用。為了更直觀的理解，我們編寫下面這個程序。

public class StringExample {
    private int value = 1;
    public final static int fs=101;

    public static void main(String[] args) {
        String a="ab";
        String b="a"+"b";
        String c=a+b;
    }
}

上述程序編譯後，通過javap -v StringExample.class查看該類的位元組碼文件，截取部分內容如下。

Constant pool:
   #1 = Methodref          #9.#32         // java/lang/Object."<init>":()V
   #2 = Fieldref           #8.#33         // org/example/cl07/StringExample.value:I
   #3 = String             #34            // ab
   #4 = Class              #35            // java/lang/StringBuilder
   #5 = Methodref          #4.#32         // java/lang/StringBuilder."<init>":()V
   #6 = Methodref          #4.#36         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StrvalueingBuilder;
   #7 = Methodref          #4.#37         // java/lang/StringBuilder.toString:()Ljava/lang/String;
   #8 = Class              #38            // org/example/cl07/StringExample
   #9 = Class              #39            // java/lang/Object
  #10 = Utf8               value
  #11 = Utf8               I
  #12 = Utf8               fs
  #13 = Utf8               ConstantValue
  #14 = Integer            101
  #15 = Utf8               <init>
  #16 = Utf8               ()V
  #17 = Utf8               Code
  #18 = Utf8               LineNumberTable
  #19 = Utf8               LocalVariableTable
  #20 = Utf8               this
  #21 = Utf8               Lorg/example/cl07/StringExample;
  #22 = Utf8               main
  #23 = Utf8               ([Ljava/lang/String;)V
  #24 = Utf8               args
  #25 = Utf8               [Ljava/lang/String;
  #26 = Utf8               a
  #27 = Utf8               Ljava/lang/String;
  #28 = Utf8               b
  #29 = Utf8               c
  #30 = Utf8               SourceFile
  #31 = Utf8               StringExample.java
  #32 = NameAndType        #15:#16        // "<init>":()V
  #33 = NameAndType        #10:#11        // value:I
  #34 = Utf8               ab
  #35 = Utf8               java/lang/StringBuilder
  #36 = NameAndType        #40:#41        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #37 = NameAndType        #42:#43        // toString:()Ljava/lang/String;
  #38 = Utf8               org/example/cl07/StringExample
  #39 = Utf8               java/lang/Object
  #40 = Utf8               append
  #41 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #42 = Utf8               toString
  #43 = Utf8               ()Ljava/lang/String;

我們關注一下Constant pool描述的部分，表示Class文件的常量池。在該常量池中主要存放兩類常量。

1. 字面量。
2. 符號引用。

字面量

• 字面量，給基本類型變量賦值的方式就叫做字面量或者字面值。 比如：String a=「b」 ，這裡「b」就是字符串字面量，同樣類推還有整數字面值、浮點類型字面量、字符字面量。

  在上述代碼中，字面量常量的位元組碼為:

  #3 = String             #34            // ab
  #26 = Utf8               a
  #34 = Utf8               ab
  

• 用final修飾的成員變量、靜態變量、實例變量、局部變量，比如：

    #11 = Utf8               I
    #12 = Utf8               fs
    #13 = Utf8               ConstantValue
    #14 = Integer            101
  

從上面的位元組碼來看，字面量和final修飾的屬性是保存在常量池中，這些存在於常量池的字面量，指得是數據的值，比如ab，101。

對於基本數據類型，比如private int value=1，在常量池中只保留了他的字段描述符（I）和字段名稱(value)，它的字面量不會存在與常量池。

  #10 = Utf8               value
  #11 = Utf8               I

另外，對於String c=a+b;，c這個屬性的值也沒有保存到常量池，因為在編譯期間，a和b的值時不確定的。

#29 = Utf8               c
#35 = Utf8               java/lang/StringBuilder
#36 = NameAndType        #40:#41        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
#37 = NameAndType        #42:#43        // toString:()Ljava/lang/String;
#39 = Utf8               java/lang/Object
#40 = Utf8               append
#41 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;

如果，我們把代碼修改成下面這種形式

public static void main(String[] args) {
  final String a="ab";
  final String b="a"+"b";
  String c=a+b;
}

重新生成位元組碼之後，可以看到位元組碼發生了變化，c這個屬性的值abab也保存到了常量池中。

#26 = Utf8               c
#27 = Utf8               SourceFile
#28 = Utf8               StringExample.java
#29 = NameAndType        #12:#13        // "<init>":()V
#30 = NameAndType        #7:#8          // value:I
#31 = Utf8               ab
#32 = Utf8               abab

符號引用

符號引用主要設涉及編譯原理方面的概念，包括下面三類常量:

1. 類和接口的全限定名(Full Qualified Name)，也就是Ljava/lang/String;，主要用於在運行時解析得到類的直接引用。

     #23 = Utf8               ([Ljava/lang/String;)V
     #25 = Utf8               [Ljava/lang/String;
     #27 = Utf8               Ljava/lang/String;
   

2. 字段的名稱和描述符(Descriptor)，字段也就是類或者接口中聲明的變量，包括類級別變量(static)和實例級的變量。

   #1 = Methodref          #9.#32         // java/lang/Object."<init>":()V
   #2 = Fieldref           #8.#33         // org/example/cl07/StringExample.value:I
   #3 = String             #34            // ab
   #4 = Class              #35            // java/lang/StringBuilder
   #5 = Methodref          #4.#32         // java/lang/StringBuilder."<init>":()V
   #6 = Methodref          #4.#36         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StrvalueingBuilder;
   #7 = Methodref          #4.#37         // java/lang/StringBuilder.toString:()Ljava/lang/String;
   #8 = Class              #38            // org/example/cl07/StringExample
     
   #24 = Utf8               args
   #26 = Utf8               a
   #28 = Utf8               b
   #29 = Utf8               c
   

3. 方法的名稱和描述符,方法的描述類似於JNI動態註冊時的「方法簽名」，也就是參數類型+返回值類型，比如下面的這種位元組碼，表示main方法和String返回類型。

     #19 = Utf8               main
     #20 = Utf8               ([Ljava/lang/String;)V
   

小結：在Class文件中，存在着一些不會發生變化的東西，比如一個類的名字、類的字段名字/所屬數據類型、方法名稱/返回類型/參數名、常量、字面量等。這些在JVM解釋執行程序的時候非常重要，所以編譯器將源代碼編譯成class文件之後，會用一部分位元組分類存儲這些不變的代碼，而這些位元組我們就稱為常量池。

運行時常量池

運行時常量池是每一個類或者接口的常量池（Constant Pool)的運行時的表現形式。

我們知道，一個類的加載過程，會經過：加載、連接（驗證、準備、解析）、初始化的過程，而在類加載這個階段，需要做以下幾件事情：

1. 通過一個類的全類限定名獲取此類的二進制位元組流。

2. 在堆內存生成一個java.lang.Class對象,代表加載這個類,做為這個類的入口。

3. 將class位元組流的靜態存儲結構轉化成方法區(元空間）的運行時數據結構。

而其中第三點，將class位元組流代表的靜態儲存結構轉化為方法區的運行時數據結構這個過程，就包含了class文件常量池進入運行時常量池的過程。

所以，運行時常量池的作用是存儲class文件常量池中的符號信息，在類的解析階段會把這些符號引用轉換成直接引用(實例對象的內存地址),翻譯出來的直接引用也是存儲在運行時常量池中。class文件常量池的大部分數據會被加載到運行時常量池。

運行時常量池保存在方法區（JDK1.8元空間）中，它是全局共享的，不同的類共用一個運行時常量池。

另外，運行時常量池具有動態性的特徵，它的內容並不是全部來源與編譯後的class文件，在運行時也可以通過代碼生成常量並放入運行時常量池。比如String.intern()方法。

字符串常量池

字符串常量池，簡單來說就是專門針對String類型設計的常量池。

字符串常量池的常用創建方式有兩種。

String a="Hello";
String b=new String("Mic");

1. a這個變量，是在編譯期間就已經確定的，會進入到字符串常量池。

2. b這個變量，是通過new關鍵字實例化，new是創建一個對象實例並初始化該實例，因此這個字符串對象是在運行時才能確定的，創建的實例在堆空間上。

字符串常量池存儲在堆內存空間中，創建形式如下圖所示。

當使用String a=「Hello」這種方式創建字符串對象時，JVM首先會先檢查該字符串對象是否存在與字符串常量池中，如果存在，則直接返回常量池中該字符串的引用。否則，會在常量池中創建一個新的字符串，並返回常量池中該字符串的引用。（這種方式可以減少同一個字符串被重複創建，節約內存，這也是享元模式的體現）。

如下圖所示，如果再通過String c=「Hello」創建一個字符串，發現常量池已經存在了Hello這個字符串，則直接把該字符串的引用返回即可。（String裏面的享元模式設計）

當使用String b=new String(「Mic」)這種方式創建字符串對象時，由於String本身的不可變性（後續分析），因此在JVM編譯過程中，會把Mic放入到Class文件的常量池中，在類加載時，會在字符串常量池中創建Mic這個字符串。接着使用new關鍵字，在堆內存中創建一個String對象並指向常量池中Mic字符串的引用。

如下圖所示，如果再通過new String(「Mic」)創建一個字符串對象，此時由於字符串常量池已經存在Mic，所以只需要在堆內存中創建一個String對象即可。

簡單總結一下：JVM之所以單獨設計字符串常量池，是JVM為了提高性能以及減少內存開銷的一些優化：

1. String對象作為Java語言中重要的數據類型，是內存中佔據空間最大的一個對象。高效地使用字符串，可以提升系統的整體性能。
2. 創建字符串常量時，首先檢查字符串常量池是否存在該字符串，如果有，則直接返回該引用實例，不存在，則實例化該字符串放入常量池中。

字符串常量池是JVM所維護的一個字符串實例的引用表，在HotSpot VM中，它是一個叫做StringTable的全局表。在字符串常量池中維護的是字符串實例的引用，底層C++實現就是一個Hashtable。這些被維護的引用所指的字符串實例，被稱作」被駐留的字符串」或」interned string」或通常所說的」進入了字符串常量池的字符串」!

封裝類常量池

除了字符串常量池，Java的基本類型的封裝類大部分也都實現了常量池。包括Byte,Short,Integer,Long,Character,Boolean

注意，浮點數據類型Float,Double是沒有常量池的。

封裝類的常量池是在各自內部類中實現的，比如IntegerCache(Integer的內部類)。要注意的是，這些常量池是有範圍的：

• Byte,Short,Integer,Long : [-128~127]
• Character : [0~127]
• Boolean : [True, False]

測試代碼如下：

public static void main(String[] args) {
  Character a=129;
  Character b=129;
  Character c=120;
  Character d=120;
  System.out.println(a==b);
  System.out.println(c==d);
  System.out.println("...integer...");
  Integer i=100;
  Integer n=100;
  Integer t=290;
  Integer e=290;
  System.out.println(i==n);
  System.out.println(t==e);
}

運行結果：

false
true
...integer...
true
false

封裝類的常量池，其實就是在各個封裝類裏面自己實現的緩存實例（並不是JVM虛擬機層面的實現），如在Integer中，存在IntegerCache，提前緩存了-128~127之間的數據實例。意味着這個區間內的數據，都採用同樣的數據對象。這也是為什麼上面的程序中，通過==判斷得到的結果為true。

這種設計其實就是享元模式的應用。

private static class IntegerCache {
  static final int low = -128;
  static final int high;
  static final Integer cache[];

  static {
    // high value may be configured by property
    int h = 127;
    String integerCacheHighPropValue =
      sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    if (integerCacheHighPropValue != null) {
      try {
        int i = parseInt(integerCacheHighPropValue);
        i = Math.max(i, 127);
        // Maximum array size is Integer.MAX_VALUE
        h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
      } catch( NumberFormatException nfe) {
        // If the property cannot be parsed into an int, ignore it.
      }
    }
    high = h;

    cache = new Integer[(high - low) + 1];
    int j = low;
    for(int k = 0; k < cache.length; k++)
      cache[k] = new Integer(j++);

    // range [-128, 127] must be interned (JLS7 5.1.7)
    assert IntegerCache.high >= 127;
  }

  private IntegerCache() {}
}

封裝類常量池的設計初衷其實String相同，也是針對頻繁使用的數據區間進行緩存，避免頻繁創建對象的內存開銷。

關於字符串常量池的問題探索

在上述常量池中，關於String字符串常量池的設計，還有很多問題需要探索：

1. 如果常量池中已經存在某個字符串常量，後續定義相同字符串的字面量時，是如何指向同一個字符串常量的引用？也就是下面這段代碼的斷言結果是true。

   String a="Mic";
   String b="Mic";
   assert(a==b); //true
   

2. 字符串常量池的容量到底有多大？

3. 為什麼要設計針對字符串單獨設計一個常量池？

為什麼要設計針對字符串單獨設計一個常量池？

首先，我們來看一下String的定義。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0
}

從上述源碼中可以發現。

1. String這個類是被final修飾的，代表該類無法被繼承。
2. String這個類的成員屬性value[]也是被final修飾，代表該成員屬性不可被修改。

因此String具有不可變的特性，也就是說String一旦被創建，就無法更改。這麼設計的好處有幾個。

1. 方便實現字符串常量池： 在Java中，由於會大量的使用String常量，如果每一次聲明一個String都創建一個String對象，那將會造成極大的空間資源的浪費。Java提出了String pool的概念，在堆中開闢一塊存儲空間String pool，當初始化一個String變量時，如果該字符串已經存在了，就不會去創建一個新的字符串變量，而是會返回已經存在了的字符串的引用。如果字符串是可變的，某一個字符串變量改變了其值，那麼其指向的變量的值也會改變，String pool將不能夠實現！
2. 線程安全性，在並發場景下，多個線程同時讀一個資源，是安全的，不會引發競爭，但對資源進行寫操作時是不安全的，不可變對象不能被寫，所以保證了多線程的安全。
3. 保證 hash 屬性值不會頻繁變更。確保了唯一性，使得類似HashMap容器才能實現相應的key-value緩存功能，於是在創建對象時其hashcode就可以放心的緩存了，不需要重新計算。這也就是Map喜歡將String作為Key的原因，處理速度要快過其它的鍵對象。所以HashMap中的鍵往往都使用String。

注意，由於String的不可變性可以方便實現字符串常量池這一點很重要，這時實現字符串常量池的前提。

字符串常量池，其實就是享元模式的設計，它和在JDK中提供的IntegerCache、以及Character等封裝對象的緩存設計類似，只是String是JVM層面的實現。

字符串的分配，和其他的對象分配一樣，耗費高昂的時間與空間代價。JVM為了提高性能和減少內存開銷，在實例化字符串常量的時候進行了一些優化。為 了減少在JVM中創建的字符串的數量，字符串類維護了一個字符串池，每當代碼創建字符串常量時，JVM會首先檢查字符串常量池。如果字符串已經存在池中， 就返回池中的實例引用。如果字符串不在池中，就會實例化一個字符串並放到池中。Java能夠進行這樣的優化是因為字符串是不可變的，可以不用擔心數據衝突 進行共享。

我們把字符串常量池當成是一個緩存，通過雙引號定義一個字符串常量時，首先從字符串常量池中去查找，找到了就直接返回該字符串常量池的引用，否則就創建一個新的字符串常量放在常量池中。

常量池有多大呢?

我想大家一定和我一樣好奇，常量池到底能存儲多少個常量？

前面我們說過，常量池本質上是一個hash表，這個hash表示不可動態擴容的。也就意味着極有可能出現單個 bucket 中的鏈表很長，導致性能降低。

在JDK1.8中，這個hash表的固定Bucket數量是60013個，我們可以通過下面這個參數配置指定數量

-XX:StringTableSize=N

可以增加下面這個虛擬機參數，來打印常量池的數據。

-XX:+PrintStringTableStatistics

增加參數後，運行下面這段代碼。

public class StringExample {
    private int value = 1;
    public final static int fs=101;

    public static void main(String[] args) {
        final String a="ab";
        final String b="a"+"b";
        String c=a+b;
    }
}

在JVM退出時，會打印常量池的使用情況如下:

SymbolTable statistics:
Number of buckets       :     20011 =    160088 bytes, avg   8.000
Number of entries       :     12192 =    292608 bytes, avg  24.000
Number of literals      :     12192 =    470416 bytes, avg  38.584
Total footprint         :           =    923112 bytes
Average bucket size     :     0.609
Variance of bucket size :     0.613
Std. dev. of bucket size:     0.783
Maximum bucket size     :         6
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :       889 =     21336 bytes, avg  24.000
Number of literals      :       889 =     59984 bytes, avg  67.474
Total footprint         :           =    561424 bytes
Average bucket size     :     0.015
Variance of bucket size :     0.015
Std. dev. of bucket size:     0.122
Maximum bucket size     :         2

可以看到字符串常量池的總大小是60013，其中字面量是889。

字面量是什麼時候進入到字符串常量池的

字符串字面量，和其他基本類型的字面量或常量不同，並不會在類加載中的解析（resolve） 階段填充並駐留在字符串常量池中，而是以特殊的形式存儲在 運行時常量池（Run-Time Constant Pool） 中。而是只有當此字符串字面量被調用時（如對其執行ldc位元組碼指令，將其添加到棧頂），HotSpot VM才會對其進行resolve，為其在字符串常量池中創建對應的String實例。

具體來說，應該是在執行ldc指令時（該指令表示int、float或String型常量從常量池推送至棧頂）

在JDK1.8的HotSpot VM中，這種未真正解析（resolve）的String字面量，被稱為pseudo-string，以JVM_CONSTANT_String的形式存放在運行時常量池中，此時並未為其創建String實例。

在編譯期，字符串字面量以”CONSTANT_String_info”+”CONSTANT_Utf8_info”的形式存放在class文件的 常量池（Constant Pool） 中；

在類加載之後，字符串字面量以”JVM_CONSTANT_UnresolvedString(JDK1.7)”或者”JVM_CONSTANT_String(JDK1.8)”的形式存放在 運行時常量池（Run-time Constant Pool） 中；

在首次使用某個字符串字面量時，字符串字面量以真正的String對象的方式存放在 字符串常量池（String Pool） 中。

通過下面這段代碼可以證明。

public static void main(String[] args) {
  String a =new String(new char[]{'a','b','c'});
  String b = a.intern();
  System.out.println(a == b);

  String x =new String("def");
  String y = x.intern();
  System.out.println(x == y);
}

使用new char[]{『a』,』b』,』c』}構建的字符串，並沒有在編譯的時候使用常量池，而是在調用a.intern()時，將abc保存到常量池並返回該常量池的引用。

intern()方法

在Integer中的valueOf方法中，我們可以看到，如果傳遞的值i是在IntegerCache.low和IntegerCache.high範圍以內，則直接從IntegerCache.cache中返回緩存的實例對象。

public static Integer valueOf(int i) {
  if (i >= IntegerCache.low && i <= IntegerCache.high)
    return IntegerCache.cache[i + (-IntegerCache.low)];
  return new Integer(i);
}

那麼，在String類型中，既然存在字符串常量池，那麼有沒有方法能夠實現類似於IntegerCache的功能呢？

答案是：intern()方法。由於字符串池是虛擬機層面的技術，所以在String的類定義中並沒有類似IntegerCache這樣的對象池，String類中提及緩存/池的概念只有intern() 這個方法。

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

這個方法的作用是：去拿String的內容去Stringtable里查表，如果存在，則返回引用，不存在，就把該對象的”引用”保存在Stringtable表裡。

比如下面這段程序：

public static void main(String[] args) {
  String str = new String("Hello World");
  String str1=str.intern();
  String str2 = "Hello World";
  System.out.print(str1 == str2);
}

運行的結果為：true。

實現邏輯如下圖所示，str1通過調用str.intern()去常量池表中獲取Hello World字符串的引用，接着str2通過字面量的形式聲明一個字符串常量，由於此時Hello World已經存在於字符串常量池中，所以同樣返回該字符串常量Hello World的引用，使得str1和str2具有相同的引用地址，從而運行結果為true。

總結：intern方法會從字符串常量池中查詢當前字符串是否存在：

• 若不存在就會將當前字符串放入常量池中，並返回當地字符串地址引用。
• 如果存在就返回字符串常量池那個字符串地址。

注意，所有字符串字面量在初始化時，會默認調用intern()方法。

這段程序，之所以a==b，是因為聲明a時，會通過intern()方法去字符串常量池中查找是否存在字符串Hello，由於不存在，則會創建一個。同理，變量b也同樣如此，所以b在聲明時，發現字符常量池中已經存在Hello的字符串常量，所以直接返回該字符串常量的引用。

public static void main(String[] args) {
  String a="Hello";
  String b="Hello";
}

OK，學習到這裡，是不是感覺自己懂了？我出一道題目來考考大家，下面這段程序的運行結果是什麼？

public static void main(String[] args) {
  String a =new String(new char[]{'a','b','c'});
  String b = a.intern();
  System.out.println(a == b);

  String x =new String("def");
  String y = x.intern();
  System.out.println(x == y);
}

正確答案是：

true
false

第二個輸出為false還可以理解，因為new String(「def」)會做兩件事：

1. 在字符串常量池中創建一個字符串def。
2. new關鍵字創建一個實例對象string，並指向字符串常量池def的引用。

而x.intern()，是從字符串常量池獲取def的引用，他們的指向地址不同，我後面的內容還會詳細解釋。

第一個輸出結果為true是為啥捏？

JDK文檔中關於intern()方法的說明：當調用intern方法時，如果常量池（內置在 JVM 中的）中已經包含相同的字符串，則返回池中的字符串。否則，將此String對象添加到池中，並返回對該String對象的引用。

在構建String a的時候，使用new char[]{『a』,』b』,』c』}初始化字符串時（不會自動調用intern()，字符串採用懶加載方式進入到常量池），並沒有在字符串常量池中構建abc這個字符串實例。所以當調用a.intern()方法時，會把該String對象添加到字符常量池中，並返回對該String對象的引用，所以a和b指向的引用地址是同一個。

問題回答

面試題：String a = “ab”; String b = “a” + “b”; a == b 是否相等

回答： a==b是相等的，原因如下：

1. 變量a和b都是常量字符串，其中b這個變量，在編譯時，由於不存在可變化的因素，所以編譯器會直接把變量b賦值為ab（這個是屬於編譯器優化範疇，也就是編譯之後，b會保存到Class常量池中的字面量）。
2. 對於字符串常量，初始化a時， 會在字符串常量池中創建一個字符串ab並返回該字符串常量池的引用。
3. 對於變量b，賦值ab時，首先從字符串常量池中查找是否存在相同的字符串，如果存在，則返回該字符串引用。
4. 因此，a和b所指向的引用是同一個，所以a==b成立。

問題總結

關於常量池部分的內容，要比較深入和全面的理解，還是需要花一些時間的。

比如大家通過閱讀上面的內容，認為對字符串常量池有一個非常深入的理解，可以，我們再來看一個問題：

public static void main(String[] args) {
  String str = new String("Hello World");
  String str1=str.intern();
  System.out.print(str == str1);
}

上面這段代碼，很顯然返回false，原因如下圖所示。很明顯str和str1所指向的引用地址不是同一個。

但是我們把上述代碼改造一下：

public static void main(String[] args) {
  String str = new String("Hello World")+new String("!");
  String str1=str.intern();
  System.out.print(str == str1);
}

上述程序輸出的結果變成了：true。 為什麼呢？

這裡也是JVM編譯器層面做的優化，因為String是不可變類型，所以理論上來說，上述程序的執行邏輯是：通過+進行字符串拼接時，相當於把原有的String變量指向的字符串常量HelloWorld取出來，加上另外一個String變量指向的字符串常量!，再生成一個新的對象。

假設我們是通過for循環來對String變量進行拼接，那將會生成大量的對象，如果這些對象沒有被及時回收，會造成非常大的內存浪費。

所以JVM優化之後，其實是通過StringBuilder來進行拼接，也就是只會產生一個對象實例StringBuilder，然後再通過append方法來拼接。

為了證明我說的情況，來看一下上述代碼的位元組碼。

 public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=4, locals=3, args_size=1
         0: new           #3                  // class java/lang/StringBuilder
         3: dup
         4: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
         7: new           #5                  // class java/lang/String
        10: dup
        11: ldc           #6                  // String Hello World
        13: invokespecial #7                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
        16: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        19: new           #5                  // class java/lang/String
        22: dup
        23: ldc           #9                  // String !
        25: invokespecial #7                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
        28: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        31: invokevirtual #10                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        34: astore_1
        35: aload_1
        36: invokevirtual #11                 // Method java/lang/String.intern:()Ljava/lang/String;
        39: astore_2
        40: getstatic     #12                 // Field java/lang/System.out:Ljava/io/PrintStream;
        43: aload_1
        44: aload_2
        45: if_acmpne     52
        48: iconst_1
        49: goto          53
        52: iconst_0
        53: invokevirtual #13                 // Method java/io/PrintStream.print:(Z)V
        56: return

從位元組碼中可以看到，構建了一個StringBuilder，

 0: new           #3                  // class java/lang/StringBuilder

然後把字符串常量通過append方法進行拼接，最後調用toString()方法得到一個字符串常量。

16: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
28: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
31: invokevirtual #10                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

因此，上述代碼，等價於下面這種形式。

public static void main(String[] args) {
  StringBuilder sb=new StringBuilder().append(new String("Hello World")).append(new String("!"));
  String str=sb.toString();
  String str1=str.intern();
  System.out.print(str == str1);
}

所以，得到的結果是true。

基於這個問題的變體還有很多，比如再來變一次，下面這段程序的運行結果是多少？

public static void main(String[] args) {
  String s1 = "a";
  String s2 = "b";
  String s3 = "ab";
  String s4 = s1 + s2;
  System.out.println(s3 == s4);
}

答案是false。

因為上述程序等價於， s3和s4指向不同的地址引用，自然不相等。

public static void main(String[] args) {
  String s1 = "a";
  String s2 = "b";
  String s3 = "ab";
  StringBuilder sb=new StringBuilder().append(s1).append(s2);
  String s4 = sb.toString();
  System.out.println(s3 == s4);
}

總結： 只有足夠清晰的理解了字符串常量池相關的所有知識點，不管面試過程中如何變化，你都能準確回答，這就是知識的力量！
版權聲明：本博客所有文章除特別聲明外，均採用 CC BY-NC-SA 4.0 許可協議。轉載請註明來自 Mic帶你學架構！
如果本篇文章對您有幫助，還請幫忙點個關注和贊，您的堅持是我不斷創作的動力。歡迎關注「跟着Mic學架構」公眾號公眾號獲取更多技術乾貨！