在講解String之前，我們先了解一下Java的記憶體結構。
一、Java記憶體模型
按照官方的說法：Java 虛擬機具有一個堆，堆是運行時資料區域，所有類實體和陣列的記憶體均從此處分配。
JVM主要管理兩種型別記憶體：堆和非堆，堆記憶體（Heap Memory）是在 Java 虛擬機啟動時創建，非堆記憶體(Non-heap Memory)是在JVM堆之外的記憶體。
簡單來說，非堆包含方法區、JVM內部處理或優化所需的記憶體（如 JITCompiler，Just-in-time Compiler，即時編譯后的代碼快取）、每個類結構（如運行時常數池、欄位和方法資料）以及方法和構造方法的代碼。
Java的堆是一個運行時資料區,類的(物件從中分配空間。這些物件通過new、newarray、 anewarray和multianewarray等指令建立，它們不需要程式代碼來顯式的釋放。堆是由垃圾回收來負責的，堆的優勢是可以動態地分配記憶體大小，生存期也不必事先告訴編譯器，因為它是在運行時動態分配記憶體的，Java的垃圾收集器會自動收走這些不再使用的資料。但缺點是，由于要在運行時動態分配記憶體，存取速度較慢。 堆疊的優勢是，存取速度比堆要快，僅次于暫存器，堆疊資料可以共享。但缺點是，存在堆疊中的資料大小與生存期必須是確定的，缺乏靈活性。堆疊中主要存放一些基本型別的變數資料（int, short, long, byte, float, double, boolean, char）和物件句柄(參考)。
虛擬機必須為每個被裝載的型別維護一個常量池。常量池就是該型別所用到常量的一個有序集合，包括直接常量（string,integer和 floating point常量）和對其他型別，欄位和方法的符號參考。 對于String常量，它的值是在常量池中的。而JVM中的常量池在記憶體當中是以表的形式存在的， 對于String型別，有一張固定長度的CONSTANT_String_info表用來存盤文字字串值，注意：該表只存盤文字字串值，不存盤符號參考。說到這里，對常量池中的字串值的存盤位置應該有一個比較明了的理解了。在程式執行的時候,常量池會儲存在Method Area,而不是堆中。常量池中保存著很多String物件; 并且可以被共享使用，因此它提高了效率
具體關于JVM和記憶體等知識請參考：
JVM 基礎知識
Java 記憶體模型及GC原理
二、案例決議
public static void main(String[] args) {
/**
* 情景一：字串池
* JAVA虛擬機(JVM)中存在著一個字串池，其中保存著很多String物件;
* 并且可以被共享使用，因此它提高了效率。
* 由于String類是final的，它的值一經創建就不可改變。
* 字串池由String類維護，我們可以呼叫intern()方法來訪問字串池。
*/
String s1 = "abc";
//↑ 在字串池創建了一個物件
String s2 = "abc";
//↑ 字串pool已經存在物件“abc”(共享),所以創建0個物件，累計創建一個物件
System.out.println("s1 == s2 : "+(s1==s2));
//↑ true 指向同一個物件，
System.out.println("s1.equals(s2) : " + (s1.equals(s2)));
//↑ true 值相等
//↑------------------------------------------------------over
/**
* 情景二：關于new String("")
*
*/
String s3 = new String("abc");
//↑ 創建了兩個物件，一個存放在字串池中，一個存在與堆區中；
//↑ 還有一個物件參考s3存放在堆疊中
String s4 = new String("abc");
//↑ 字串池中已經存在“abc”物件，所以只在堆中創建了一個物件
System.out.println("s3 == s4 : "+(s3==s4));
//↑false s3和s4堆疊區的地址不同，指向堆區的不同地址；
System.out.println("s3.equals(s4) : "+(s3.equals(s4)));
//↑true s3和s4的值相同
System.out.println("s1 == s3 : "+(s1==s3));
//↑false 存放的地區多不同，一個堆疊區，一個堆區
System.out.println("s1.equals(s3) : "+(s1.equals(s3)));
//↑true 值相同
//↑------------------------------------------------------over
/**
* 情景三：
* 由于常量的值在編譯的時候就被確定(優化)了。
* 在這里，"ab"和"cd"都是常量，因此變數str3的值在編譯時就可以確定。
* 這行代碼編譯后的效果等同于： String str3 = "abcd";
*/
String str1 = "ab" + "cd"; //1個物件
String str11 = "abcd";
System.out.println("str1 = str11 : "+ (str1 == str11));
//↑------------------------------------------------------over
/**
* 情景四：
* 區域變數str2,str3存盤的是存盤兩個拘留字串物件(intern字串物件)的地址。
*
* 第三行代碼原理(str2+str3)：
* 運行期JVM首先會在堆中創建一個StringBuilder類，
* 同時用str2指向的拘留字串物件完成初始化，
* 然后呼叫append方法完成對str3所指向的拘留字串的合并，
* 接著呼叫StringBuilder的toString()方法在堆中創建一個String物件，
* 最后將剛生成的String物件的堆地址存放在區域變數str3中。
*
* 而str5存盤的是字串池中"abcd"所對應的拘留字串物件的地址。
* str4與str5地址當然不一樣了。
*
* 記憶體中實際上有五個字串物件：
* 三個拘留字串物件、一個String物件和一個StringBuilder物件。
*/
String str2 = "ab"; //1個物件
String str3 = "cd"; //1個物件
String str4 = str2+str3;
String str5 = "abcd";
System.out.println("str4 = str5 : " + (str4==str5)); // false
//↑------------------------------------------------------over
/**
* 情景五：
* JAVA編譯器對string + 基本型別/常量 是當成常量運算式直接求值來優化的。
* 運行期的兩個string相加，會產生新的物件的，存盤在堆(heap)中
*/
String str6 = "b";
String str7 = "a" + str6;
String str67 = "ab";
System.out.println("str7 = str67 : "+ (str7 == str67));
//↑str6為變數，在運行期才會被決議。
final String str8 = "b";
String str9 = "a" + str8;
String str89 = "ab";
System.out.println("str9 = str89 : "+ (str9 == str89));
//↑str8為常量變數，編譯期會被優化
//↑------------------------------------------------------over
}1.String類初始化后是不可變的(immutable)
這一說又要說很多，大家只要知道String的實體一旦生成就不會再改變了，比如說：String str=”kv”+”ill”+” “+”ans”; 就是有4個字串常量，首先”kv”和”ill”生成了”kvill”存在記憶體中，然后”kvill”又和” ” 生成 “kvill “存在記憶體中，最后又和生成了”kvill ans”;并把這個字串的地址賦給了str,就是因為String的”不可變”產生了很多臨時變數，這也就是為什么建議用StringBuffer的原 因了，因為StringBuffer是可改變的。 下面是一些String相關的常見問題： String中的final用法和理解 final StringBuffer a = new StringBuffer("111"); final StringBuffer b = new StringBuffer("222"); a=b;//此句編譯不通過 final StringBuffer a = new StringBuffer("111"); a.append("222");// 編譯通過 可見，final只對參考的"值"(即記憶體地址)有效，它迫使參考只能指向初始指向的那個物件，改變它的指向會導致編譯期錯誤。至于它所指向的物件的變化，final是不負責的。
2.代碼中的字串常量在編譯的程序中收集并放在class檔案的常量區中，如"123"、"123"+"456"等，含有變數的運算式不會收錄，如"123"+a。
3.JVM在加載類的時候，根據常量區中的字串生成常量池，每個字符序列如"123"會生成一個實體放在常量池里，這個實體是不在堆里的，也不會被GC，這個實體的value屬性從原始碼的建構式看應該是用new創建陣列置入123的，所以按我的理解此時value存放的字符陣列地址是在堆里，如果有誤的話歡迎大家指正。
4.使用String不一定創建物件
在執行到雙引號包含字串的陳述句時，如String a = "123"，JVM會先到常量池里查找，如果有的話回傳常量池里的這個實體的參考，否則的話創建一個新實體并置入常量池里。如果是 String a = "123" + b (假設b是"456")，前半部分"123"還是走常量池的路線，但是這個+運算子其實是轉換成[SringBuffer].Appad()來實作的，所以最終a得到是一個新的實體參考，而且a的value存放的是一個新申請的字符陣列記憶體空間的地址(存放著"123456")，而此時"123456"在常量池中是未必存在的。
要注意: 我們在使用諸如String str = "abc"；的格式定義類時，總是想當然地認為，創建了String類的物件str。擔心陷阱！物件可能并沒有被創建！而可能只是指向一個先前已經創建的物件。只有通過new()方法才能保證每次都創建一個新的物件
5.使用new String，一定創建物件
在執行String a = new String("123")的時候，首先走常量池的路線取到一個實體的參考，然后在堆上創建一個新的String實體，走以下建構式給value屬性賦值，然后把實體參考賦值給a：
public String(String original) {
int size = original.count;
char[] originalValue = original.value;
char[] v;
if (originalValue.length > size) {
// The array representing the String is bigger than the new
// String itself. Perhaps this constructor is being called
// in order to trim the baggage, so make a copy of the array.
int off = original.offset;
v = Arrays.copyOfRange(originalValue, off, off+size);
} else {
// The array representing the String is the same
// size as the String, so no point in making a copy.
v = originalValue;
}
this.offset = 0;
this.count = size;
this.value = v;
}從中我們可以看到，雖然是新創建了一個String的實體，但是value是等于常量池中的實體的value，即是說沒有new一個新的字符陣列來存放"123"。
如果是String a = new String("123"+b)的情況，首先看回第4點，"123"+b得到一個實體后，再按上面的建構式執行。
6.String.intern()
String物件的實體呼叫intern方法后，可以讓JVM檢查常量池，如果沒有實體的value屬性對應的字串序列比如"123"(注意是檢查字串序列而不是檢查實體本身)，就將本實體放入常量池，如果有當前實體的value屬性對應的字串序列"123"在常量池中存在，則回傳常量池中"123"對應的實體的參考而不是當前實體的參考，即使當前實體的value也是"123"。
public native String intern();
存在于.class檔案中的常量池，在運行期被JVM裝載，并且可以擴充。String的 intern()方法就是擴充常量池的 一個方法；當一個String實體str呼叫intern()方法時，Java 查找常量池中 是否有相同Unicode的字串常量，如果有，則回傳其的參考，如果沒有，則在常 量池中增加一個Unicode等于str的字串并回傳它的參考；看示例就清楚了
public static void main(String[] args) {
String s0 = "kvill";
String s1 = new String("kvill");
String s2 = new String("kvill");
System.out.println( s0 == s1 ); //false
System.out.println( "**********" );
s1.intern(); //雖然執行了s1.intern(),但它的回傳值沒有賦給s1
s2 = s2.intern(); //把常量池中"kvill"的參考賦給s2
System.out.println( s0 == s1); //flase
System.out.println( s0 == s1.intern() ); //true//說明s1.intern()回傳的是常量池中"kvill"的參考
System.out.println( s0 == s2 ); //true
}最后我再破除一個錯誤的理解：有人說，“使用 String.intern() 方法則可以將一個 String 類的保存到一個全域 String 表中 ，如果具有相同值的 Unicode 字串已經在這個表中，那么該方法回傳表中已有字串的地址，如果在表中沒有相同值的字串，則將自己的地址注冊到表中”如果我把他說的這個全域的 String 表理解為常量池的話，他的最后一句話，”如果在表中沒有相同值的字串，則將自己的地址注冊到表中”是錯的：
public static void main(String[] args) {
String s1 = new String("kvill");
String s2 = s1.intern();
System.out.println( s1 == s1.intern() ); //false
System.out.println( s1 + " " + s2 ); //kvill kvill
System.out.println( s2 == s1.intern() ); //true
}在這個類中我們沒有聲名一個”kvill”常量，所以常量池中一開始是沒有”kvill”的，當我們呼叫s1.intern()后就在常量池中新添加了一 個”kvill”常量，原來的不在常量池中的”kvill”仍然存在，也就不是“將自己的地址注冊到常量池中”了。 s1==s1.intern() 為false說明原來的”kvill”仍然存在；s2現在為常量池中”kvill”的地址，所以有s2==s1.intern()為true。
StringBuffer與StringBuilder的區別，它們的應用場景是什么？
jdk的實作中StringBuffer與StringBuilder都繼承自AbstractStringBuilder，對于多執行緒的安全與非安全看到StringBuffer中方法前面的一堆synchronized就大概了解了。
這里隨便講講AbstractStringBuilder的實作原理：我們知道使用StringBuffer等無非就是為了提高java中字串連接的效率，因為直接使用+進行字串連接的話，jvm會創建多個String物件，因此造成一定的開銷。AbstractStringBuilder中采用一個char陣列來保存需要append的字串，char陣列有一個初始大小，當append的字串長度超過當前char陣列容量時，則對char陣列進行動態擴展，也即重新申請一段更大的記憶體空間，然后將當前char陣列拷貝到新的位置，因為重新分配記憶體并拷貝的開銷比較大，所以每次重新申請記憶體空間都是采用申請大于當前需要的記憶體空間的方式，這里是2倍
【
StringBuffer 始于 JDK 1.0 StringBuilder 始于 JDK 1.5 從 JDK 1.5 開始，帶有字串變數的連接操作（+），JVM 內部采用的是 StringBuilder 來實作的，而之前這個操作是采用 StringBuffer 實作的。
】
我們通過一個簡單的程式來看其執行的流程：
public class Buffer {
public static void main(String[] args) {
String s1 = "aaaaa";
String s2 = "bbbbb";
String r = null;
int i = 3694;
r = s1 + i + s2;
for(int j=0;i<10;j++){
r+="23124";
}
}
}使用命令javap -c Buffer查看其位元組碼實作：
將清單1和清單2對應起來看，清單2的位元組碼中ldc指令即從常量池中加載“aaaaa”字串到堆疊頂，istore_1將“aaaaa”存到變數1中，后面的一樣，sipush是將一個短整型常量值(-32768~32767)推送至堆疊頂，這里是常量“3694”。
讓我們直接看到13,13~17是new了一個StringBuffer物件并呼叫其初始化方法，20~21則是先通過aload_1將變數1壓到堆疊頂，前面說過變數1放的就是字串常量“aaaaa”，接著通過指令invokevirtual呼叫StringBuffer的append方法將“aaaaa”拼接起來，后續的24~30同理。最后在33呼叫StringBuffer的toString函式獲得String結果并通過astore存到變數3中。
uj5u.com熱心網友回復：
深入理解，，uj5u.com熱心網友回復：
頂
uj5u.com熱心網友回復：
uj5u.com熱心網友回復：
uj5u.com熱心網友回復：
uj5u.com熱心網友回復：
頂
uj5u.com熱心網友回復：
uj5u.com熱心網友回復：
樓主關于intern()方法的說法是錯誤的，“使用 String.intern() 方法則可以將一個 String 類的保存到一個全域 String 表中 ，如果具有相同值的 Unicode 字串已經在這個表中，那么該方法回傳表中已有字串的地址，如果在表中沒有相同值的字串，則將自己的地址注冊到表中”這句話沒錯。char[] value = {'a', 'b', 'c'};
String str1 = new String(value);
String str2 = str1.intern();
System.out.println(str1 == str2);
得到true
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/230786.html
標籤：非技術區