JVM8-一道字符串題題帶你認(rèn)識常量池
請先做題并把答案記在心里
package sandwich.test2;
/**
* @author sandwich
* @date 2021/4/20
*/
public class StringTest {
public static void main(String[] args) {
String a = "abc";
String b = new String("abc");
String c = b.intern();
System.out.println(a == b);
System.out.println(b == c);
System.out.println(a == c);
}
}
答案在文章最后面
常量池
常量池的數(shù)據(jù)存儲在方法區(qū)，分以下三種
1.Class常量池（靜態(tài)常量池）
在 class 文件中除了有類的版本、字段、方法和接口等描述信息外，還有一項信息是常量池 (Constant Pool Table)，用于存放編譯期間生成的各種字面量和符號引用。
如下是一個class反匯編的內(nèi)容，請看Constant pool部分內(nèi)容
PS D:\git\test\target\classes\sandwich> javap -v .\Person.class
Classfile /D:/git/test/target/classes/sandwich/Person.class
Last modified 2021年4月17日; size 957 bytes
MD5 checksum df5c1bcb5d0f1d5be2998dd1d8d6b44e
Compiled from "Person.java"
public class sandwich.Person
minor version: 0
major version: 52
flags: (0x0021) ACC_PUBLIC, ACC_SUPER
this_class: #2 // sandwich/Person
super_class: #14 // java/lang/Object
interfaces: 0, fields: 0, methods: 3, attributes: 1
Constant pool:
#1 = Methodref #14.#35 // java/lang/Object."<init>":()V
#2 = Class #36 // sandwich/Person
#3 = Methodref #2.#35 // sandwich/Person."<init>":()V
#4 = Methodref #2.#37 // sandwich/Person.work:()I
#5 = Fieldref #38.#39 // java/lang/System.out:Ljava/io/PrintStream;
#6 = Class #40 // java/lang/StringBuilder
#7 = Methodref #6.#35 // java/lang/StringBuilder."<init>":()V
#8 = String #41 // result=
#9 = Methodref #6.#42 // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
#10 = Methodref #6.#43 // java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
#11 = Methodref #6.#44 // java/lang/StringBuilder.toString:()Ljava/lang/String;
#12 = Methodref #45.#46 // java/io/PrintStream.println:(Ljava/lang/String;)V
#13 = Methodref #14.#47 // java/lang/Object.hashCode:()I
#14 = Class #48 // java/lang/Object
#15 = Utf8 <init>
#16 = Utf8 ()V
#17 = Utf8 Code
#18 = Utf8 LineNumberTable
#19 = Utf8 LocalVariableTable
#20 = Utf8 this
#21 = Utf8 Lsandwich/Person;
#22 = Utf8 work
#23 = Utf8 ()I
#24 = Utf8 i
#25 = Utf8 I
#26 = Utf8 j
#27 = Utf8 main
#28 = Utf8 ([Ljava/lang/String;)V
#29 = Utf8 args
#30 = Utf8 [Ljava/lang/String;
#31 = Utf8 person
#32 = Utf8 z
#33 = Utf8 SourceFile
#34 = Utf8 Person.java
#35 = NameAndType #15:#16 // "<init>":()V
#36 = Utf8 sandwich/Person
#37 = NameAndType #22:#23 // work:()I
#38 = Class #49 // java/lang/System
#39 = NameAndType #50:#51 // out:Ljava/io/PrintStream;
#40 = Utf8 java/lang/StringBuilder
#41 = Utf8 result=
#42 = NameAndType #52:#53 // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
#43 = NameAndType #52:#54 // append:(I)Ljava/lang/StringBuilder;
#44 = NameAndType #55:#56 // toString:()Ljava/lang/String;
#45 = Class #57 // java/io/PrintStream
#46 = NameAndType #58:#59 // println:(Ljava/lang/String;)V
#47 = NameAndType #60:#23 // hashCode:()I
#48 = Utf8 java/lang/Object
#49 = Utf8 java/lang/System
#50 = Utf8 out
#51 = Utf8 Ljava/io/PrintStream;
#52 = Utf8 append
#53 = Utf8 (Ljava/lang/String;)Ljava/lang/StringBuilder;
#54 = Utf8 (I)Ljava/lang/StringBuilder;
#55 = Utf8 toString
#56 = Utf8 ()Ljava/lang/String;
#57 = Utf8 java/io/PrintStream
#58 = Utf8 println
#59 = Utf8 (Ljava/lang/String;)V
#60 = Utf8 hashCode
{
public sandwich.Person();
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 7: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lsandwich/Person;
public int work();
descriptor: ()I
flags: (0x0001) ACC_PUBLIC
Code:
stack=2, locals=3, args_size=1
0: iconst_3
1: istore_1
2: iconst_5
3: istore_2
4: iload_1
5: iload_2
6: iadd
7: bipush 10
9: imul
10: ireturn
LineNumberTable:
line 10: 0
line 11: 2
line 12: 4
LocalVariableTable:
Start Length Slot Name Signature
0 11 0 this Lsandwich/Person;
2 9 1 i I
4 7 2 j I
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: (0x0009) ACC_PUBLIC, ACC_STATIC
Code:
stack=3, locals=3, args_size=1
0: new #2 // class sandwich/Person
3: dup
4: invokespecial #3 // Method "<init>":()V
7: astore_1
8: aload_1
9: invokevirtual #4 // Method work:()I
12: istore_2
13: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
16: new #6 // class java/lang/StringBuilder
19: dup
20: invokespecial #7 // Method java/lang/StringBuilder."<init>":()V
23: ldc #8 // String result=
25: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
28: iload_2
29: invokevirtual #10 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
32: invokevirtual #11 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
35: invokevirtual #12 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
38: aload_1
39: invokevirtual #13 // Method java/lang/Object.hashCode:()I
42: pop
43: return
LineNumberTable:
line 16: 0
line 17: 8
line 18: 13
line 20: 38
line 21: 43
LocalVariableTable:
Start Length Slot Name Signature
0 44 0 args [Ljava/lang/String;
8 36 1 person Lsandwich/Person;
13 31 2 z I
}
SourceFile: "Person.java"
字面量：給基本類型變量賦值的方式就叫做字面量或者字面值。 比如：String a=“b” ，這里“b”就是字符串字面量，同樣類推還有整數(shù)字面值、浮點類型字面量、字符字面量。
符號引用 ：符號引用以一組符號來描述所引用的目標(biāo)。符號引用可以是任何形式的字面量，JAVA 在編譯的時候一個每個 java 類都會被編譯成一個 class 文件，但在編譯的時候虛擬機并不知道所引用類的地址(實際地址)，就用符號引用來代替，而在類的解析階段（后續(xù) JVM 類加載會具體講到）就是為了把 這個符號引用轉(zhuǎn)化成為真正的地址的階段。 一個 java 類（假設(shè)為 People 類）被編譯成一個 class 文件時，如果 People 類引用了 Tool 類，但是在編譯時 People 類并不知道引用類的實際內(nèi)存地址，因 此只能使用符號引用（org.simple.Tool）來代替。而在類裝載器裝載 People 類時，此時可以通過虛擬機獲取 Tool 類的實際內(nèi)存地址，因此便可以既將符號 org.simple.Tool 替換為 Tool 類的實際內(nèi)存地址。
2.運行時常量池
運行時常量池（Runtime Constant Pool）是每一個類或接口的常量池（Constant_Pool）的運行時表示形式，它包括了若干種不同的常量： 從編譯期可知的數(shù)值字面量到必須運行期解析后才能獲得的方法或字段引用。（這個是虛擬機規(guī)范中的描述，很生澀） 運行時常量池是在類加載完成之后，將 Class 常量池中的符號引用值轉(zhuǎn)存到運行時常量池中，類在解析之后，將符號引用替換成直接引用。
運行時常量池在 JDK1.7 版本之后，就移到堆內(nèi)存中了，這里指的是物理空間，而邏輯上還是屬于方法區(qū)（方法區(qū)是邏輯分區(qū)）。 在 JDK1.8 中，使用元空間代替永久代來實現(xiàn)方法區(qū)，但是方法區(qū)并沒有改變，所謂"Your father will always be your father"。變動的只是方法 區(qū)中內(nèi)容的物理存放位置，但是運行時常量池和字符串常量池被移動到了堆中。但是不論它們物理上如何存放，邏輯上還是屬于方法區(qū)的
3.字符串常量池
字符串常量池這個概念是最有爭議的。
我們從它的作用和 JVM 設(shè)計它用于解決什么問題的點來分析它。 以 JDK1.8 為例，字符串常量池是存放在堆中，并且與 java.lang.String 類有很大關(guān)系。設(shè)計這塊內(nèi)存區(qū)域的原因在于：String 對象作為 Java 語言中重
要的數(shù)據(jù)類型，是內(nèi)存中占據(jù)空間最大的一個對象。高效地使用字符串，可以提升系統(tǒng)的整體性能。 所以要徹底弄懂，我們的重心其實在于深入理解 String。
3.1 String 類分析（JDK1.8）
String 對象是對 char 數(shù)組進行了封裝實現(xiàn)的對象，主要有 2 個成員變量：char 數(shù)組，hash 值。
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
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -6849794470754667710L;
3.2 String 對象的不可變性
了解了 String 對象的實現(xiàn)后，你有沒有發(fā)現(xiàn)在實現(xiàn)代碼中 String 類被 final 關(guān)鍵字修飾了，而且變量 char 數(shù)組也被 final 修飾了。 我們知道類被 final 修飾代表該類不可繼承，而 char[]被 final+private 修飾，代表了 String 對象不可被更改。Java 實現(xiàn)的這個特性叫作 String 對象的不 可變性，即 String 對象一旦創(chuàng)建成功，就不能再對它進行改變。
Java 這樣做的好處在哪里呢？
1.保證 String 對象的安全性。 假設(shè) String 對象是可變的，那么 String 對象將可能被惡意修改。
2.保證 hash 屬性值不會頻繁變更。確保了唯一性，使得類似 HashMap 容器才能實現(xiàn)相應(yīng)的 key-value 緩存功能.
3.可以實現(xiàn)字符串常量池。在 Java 中，通常有兩種創(chuàng)建字符串對象的方式，一種是通過字符串常量的方式創(chuàng)建，如 String str=“abc”；另一種是字 符串變量通過 new 形式的創(chuàng)建，如 String str = new String(“abc”)。
3.3 String 的創(chuàng)建方式及內(nèi)存分配的方式
1、String str=“abc”； 當(dāng)代碼中使用這種方式創(chuàng)建字符串對象時，JVM 首先會檢查該對象是否在字符串常量池中，如果在，就返回該對象引用，否則新的字符串將在常量池中 被創(chuàng)建。這種方式可以減少同一個值的字符串對象的重復(fù)創(chuàng)建，節(jié)約內(nèi)存。（str 只是一個引用）
String str = "abc"
代碼編譯加載時，會在常量池中創(chuàng)建常量"abc"， 運行時，返回常量池中的字符串引用
堆 字符串常量池 “abc”
2、String str = new String(“abc”) 。 首先在編譯類文件時，"abc"常量字符串將會放入到常量結(jié)構(gòu)中，在類加載時，“abc"將會在常量池中創(chuàng)建；其次，在調(diào)用 new 時，JVM 命令將會調(diào)用 String 的構(gòu)造函數(shù)，同時引用常量池中的"abc” 字符串，在堆內(nèi)存中創(chuàng)建一個 String 對象；最后，str 將引用 String 對象。
String str = new String("abc")
1.代碼編譯加載時，會在常量池中創(chuàng)建常量“abc”
堆 字符串常量池 “abc” 2.在調(diào)用new是，會在堆中創(chuàng)建String對象，并引用常量池中的字符串對象char[]數(shù)組，并返回String對象引用。
堆 字符串常量池 String對象 “abc”
3、 使用 new，對象會創(chuàng)建在堆中，同時賦值的話，會在常量池中創(chuàng)建一個字符串對象，復(fù)制到堆中。 具體的復(fù)制過程是先將常量池中的字符串壓入棧中，在使用 String 的構(gòu)造方法是，會拿到棧中的字符串作為構(gòu)方法的參數(shù)。 這個構(gòu)造函數(shù)是一個 char 數(shù)組的賦值過程，而不是 new 出來的，所以是引用了常量池中的字符串對象。存在引用關(guān)系。
public class Location {
private String city;
private String region;
}
public class model{
Location location = new Location;
location.setCity("廣州");
location.setRegion("珠江新城");
}
在運行時，創(chuàng)建的String在堆中，直接創(chuàng)建，不會在常量池中創(chuàng)建
堆 字符串常量池 廣州 珠江新城
4.String str="ab"+"cd"+"ef"
前面我講過 String 對象是不可變的，如果我們使用 String 對象相加，拼接我們想要的字符串，是不是就會產(chǎn)生多個
對象呢？例如以下代碼： 分析代碼可知：首先會生成 ab 對象，再生成 abcd 對象，最后生成 abcdef 對象，從理論上來說，這段代碼是低效的。 編譯器自動優(yōu)化了這行代碼，編譯后的代碼，你會發(fā)現(xiàn)編譯器自動優(yōu)化了這行代碼，如下 String str= "abcdef";
5.intern
String 的 intern 方法，如果常量池中有相同值，就會重復(fù)使用該對象，返回對象引用。
/**
* @author sandwich
* @date 2021/4/20
*/
public class InternTest {
public static void main(String[] args) {
String a = new String("Sandwich").intern();
String b = new String("Sandwich").intern();
System.out.println(a == b);
}
}
//結(jié)果是true
1、new Sting() 會在堆內(nèi)存中創(chuàng)建一個 a 的 String 對象，"Sandwich"將會在常量池中創(chuàng)建
2、在調(diào)用 intern 方法之后，會去常量池中查找是否有等于該字符串對象的引用，有就返回引用。
3、調(diào)用 new Sting() 會在堆內(nèi)存中創(chuàng)建一個 b 的 String 對象。
4、在調(diào)用 intern 方法之后，會去常量池中查找是否有等于該字符串對象的引用，有就返回引用。 所以 a 和 b 引用的是同一個對象。
現(xiàn)在可以公布文章開頭的答案了
這道題主要是考考常量池
答案是:
false
false
true
題解：a 是常量池的字符串（在方法區(qū)）的引用，b在調(diào)用new時會在堆中創(chuàng)建String對象，并引用常量池中的字符串對象char[]數(shù)組。并返回String對象引用，c直接返回b在常量池創(chuàng)建的常量引用
