面試題：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 = https://www.cnblogs.com/mic112/p/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=https://www.cnblogs.com/mic112/p/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 =
      https://www.cnblogs.com/mic112/p/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 = https://www.cnblogs.com/mic112/p/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帶你學架構！
如果本篇文章對您有幫助，還請幫忙點個關注和贊，您的堅持是我不斷創作的動力，歡迎關注「跟著Mic學架構」公眾號公眾號獲取更多技術干貨！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/351910.html

標籤：Java

上一篇：QuantumTunnel：Netty實作

下一篇：分布式事務（四）之TCC

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