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

面試題：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. 全局字元串常量池

每個

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

指向的引用位址是同一個。

問題回答

回答：

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學架構」公衆号公衆号擷取更多技術幹貨！