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

面試考察點

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

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

背景知識

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

String a=“ab”，在JVM中發生了什麼？
String b=“a”+“b”，底層是如何實現？

JVM的執行時資料

首先，我們一起來複習一下JVM的執行時資料區。

為了讓大家有一個全域性的視角，我從類載入，到JVM執行時資料區的整體結構畫出來，如下圖所示。

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

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

字串常量池
封裝類常量池
執行時常量池
JIT編譯器

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

JVM中都有哪些常量池

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

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

Class檔案常量池
全域性字串常量池
執行時常量池

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檔案的常量池。在該常量池中主要存放兩類常量。

字面量。
符號引用。

字面量

字面量，給基本型別變數賦值的方式就叫做字面量或者字面值。比如：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

符號引用

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

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

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

欄位的名稱和描述符(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

方法的名稱和描述符,方法的描述類似於JNI動態註冊時的“方法簽名”，也就是引數型別+返回值型別，比如下面的這種位元組碼，表示main方法和String返回型別。
```
  #19 = Utf8               main
  #20 = Utf8               ([Ljava/lang/String;)V
```

小結：在Class檔案中，存在著一些不會發生變化的東西，比如一個類的名字、類的欄位名字/所屬資料型別、方法名稱/返回型別/引數名、常量、字面量等。這些在JVM解釋執行程式的時候非常重要，所以編譯器將原始碼編譯成class檔案之後，會用一部分位元組分類儲存這些不變的程式碼，而這些位元組我們就稱為常量池。

執行時常量池

執行時常量池是每一個類或者介面的常量池（Constant Pool)的執行時的表現形式。

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

通過一個類的全類限定名獲取此類的二進位制位元組流。
在堆記憶體生成一個java.lang.Class物件,代表載入這個類,做為這個類的入口。
將class位元組流的靜態儲存結構轉化成方法區(元空間）的執行時資料結構。

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

所以，執行時常量池的作用是儲存class檔案常量池中的符號資訊，在類的解析階段會把這些符號引用轉換成直接引用(例項物件的記憶體地址),翻譯出來的直接引用也是儲存在執行時常量池中。class檔案常量池的大部分資料會被載入到執行時常量池。

執行時常量池儲存在方法區（JDK1.8元空間）中，它是全域性共享的，不同的類共用一個執行時常量池。
另外，執行時常量池具有動態性的特徵，它的內容並不是全部來源與編譯後的class檔案，在執行時也可以通過程式碼生成常量並放入執行時常量池。比如String.intern()方法。

字串常量池

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

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

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

a這個變數，是在編譯期間就已經確定的，會進入到字串常量池。
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為了提高效能以及減少記憶體開銷的一些優化：

String物件作為Java語言中重要的資料型別，是記憶體中佔據空間最大的一個物件。高效地使用字串，可以提升系統的整體效能。
建立字串常量時，首先檢查字串常量池是否存在該字串，如果有，則直接返回該引用例項，不存在，則例項化該字串放入常量池中。

字串常量池是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字串常量池的設計，還有很多問題需要探索：

如果常量池中已經存在某個字串常量，後續定義相同字串的字面量時，是如何指向同一個字串常量的引用？也就是下面這段程式碼的斷言結果是true。
```
String a="Mic";
String b="Mic";
assert(a==b); //true
```
字串常量池的容量到底有多大？
為什麼要設計針對字串單獨設計一個常量池？

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

首先，我們來看一下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
}

從上述原始碼中可以發現。

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

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

方便實現字串常量池：在Java中，由於會大量的使用String常量，如果每一次宣告一個String都建立一個String物件，那將會造成極大的空間資源的浪費。Java提出了String pool的概念，在堆中開闢一塊儲存空間String pool，當初始化一個String變數時，如果該字串已經存在了，就不會去建立一個新的字串變數，而是會返回已經存在了的字串的引用。如果字串是可變的，某一個字串變數改變了其值，那麼其指向的變數的值也會改變，String pool將不能夠實現！
執行緒安全性，在併發場景下，多個執行緒同時讀一個資源，是安全的，不會引發競爭，但對資源進行寫操作時是不安全的，不可變物件不能被寫，所以保證了多執行緒的安全。
保證 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”)會做兩件事：

在字串常量池中建立一個字串def。
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是相等的，原因如下：

變數a和b都是常量字串，其中b這個變數，在編譯時，由於不存在可變化的因素，所以編譯器會直接把變數b賦值為ab（這個是屬於編譯器優化範疇，也就是編譯之後，b會儲存到Class常量池中的字面量）。
對於字串常量，初始化a時，會在字串常量池中建立一個字串ab並返回該字串常量池的引用。
對於變數b，賦值ab時，首先從字串常量池中查詢是否存在相同的字串，如果存在，則返回該字串引用。
因此，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帶你學架構！
如果本篇文章對您有幫助，還請幫忙點個關注和贊，您的堅持是我不斷創作的動力。歡迎關注同名微信公眾號獲取更多技術乾貨！

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