本章將深入分析在Java中最常用的String類，主要分析以下幾個部分：
- String類的二大特點：不可變性和不可繼承
- 關于String的使用和內存分配
- String、StringBuffer和StringBuilder之間的關系和區別
一、String類的二大特點
1.1 不可變性
String對象是不可變的，進入到String源碼中找到String構造函數會發現存儲字符的char數組是final類型的，在Java中final如果用于數組的話，那么引用指向的對象地址是不可以改變的，來保證成員變量的引用值只能通過構造函數來修改。關于使用final的用法和作用參考我寫的這篇文章 【Java基礎提高】深入分析final關鍵字(一)。
private final char value[];
public String() {
this.value = new char[0];
}
上面說到String是不可變的。可能會有同學說：“毛驢，你不對！我可以改變它”。并舉例說明，代碼如下：
public static void main(String[] args) {
String s1 = "小毛驢";
s1 = s1.concat("在敲代碼！");
System.out.println(s1);
}
控制臺輸出：
小毛驢在敲代碼
String.concat()和s1+=“在敲代碼”的功能相同，都是將2個元素拼在一起。那么我們來看下concat方法是怎么修改s1的值，代碼如下所示。原來它是重新創建了一個更大空間的新數組，分配的空間大小是（舊值長度＋新值長度），然后將舊數組里面的元素拷貝到新數組中，最后返回一個新的String實例，它并不是直接修改數組中的元素。
public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
int len = value.length;
char buf[] = Arrays.copyOf(value, len + otherLen);
str.getChars(buf, len);
return new String(buf, true);
}
另外在String類中每一個會修改String值的方法，實際上都是返回了一個新的String對象。如concat、replace等等方法。
public String replace(char oldChar, char newChar) {
if (oldChar != newChar) {
int len = value.length;
int i = -1;
char[] val = value; /* avoid getfield opcode */
while (++i < len) {
if (val[i] == oldChar) {
break;
}
}
if (i < len) {
char buf[] = new char[len];
for (int j = 0; j < i; j++) {
buf[j] = val[j];
}
while (i < len) {
char c = val[i];
buf[i] = (c == oldChar) ? newChar : c;
i++;
}
return new String(buf, true);
}
}
return this;
}
1.2 不可繼承
在Java中，當你將某個類定義為final class時，那么子類就無法繼承該類。String類就是一個final類
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
}
二、String類的使用
String類的使用大致歸納為以下幾種方法：
- 直接定義。如String s1 = "小毛驢";
- 使用new String()。如String s1 = new String("小毛驢");
- 使用+= 重載操作符。如s1+="在唱歌";
2.1 常量池
在使用String之前不得不說下方法區里的常量池，在<<深入Java虛擬機>>書中作者是這樣描述的：虛擬機必須為每個被裝載的類型維護一個常量池。常量池就是該類型所用到常量的一個有序集和，包括直接常量（string,integer和 floating point常量）和對其他類型，字段和方法的符號引用。對于String常量，它的值是在常量池中的。而JVM中的常量池在內存當中是以表的形式存在的， 對于String類型，有一張固定長度的CONSTANT_String_info表用來存儲文字字符串值，注意：該表只存儲文字字符串值，不存儲符號引 用。
對JVM和內存比較薄弱的同學參考下這篇文章：Java 內存模型及GC原理
3.2 直接定義
直接定義的原理是在程序編譯時期，先去常量池中檢查這個值（小毛驢）是否存在。如果不存在，則在常量池中開辟一個新的空間存儲這個值并在棧中創建一個引用指向它。如果存在，則直接在棧區創建一個引用指向常量池中的值，這樣既保證了常量池中值的唯一性，又能為本來內存空間較小的常量池節省一點點空間。如圖所示：
private void test1()
{
String s1 = "小毛驢";
String s2 = "在唱歌";
String s3 = s1;
System.out.println("s1 equals s3 "+s1.equals(s3));
System.out.println("s1 == s3 "+(s1==s3));
}
控制臺
s1 equals s3 true
s1 == s3 true
3.3 使用new String()
使用new String()的原理和直接定義相似，它們都會去常量池中檢查值(小毛驢)是否存在。不一樣的是new String會比直接定義多開辟一個內存空間，它會在常量池中開辟空間同時又在堆區中分配一個空間來保存該值，最后在棧區由s1來保存在堆區的內存地址。很奇怪Java這么做的意義是什么？如果常量池中的值沒有程序引用它的話，那么不是會浪費內存空間嗎？如圖所示：
private void test2()
{
String s1 = new String("小毛驢");
String s2 = s1;
String s3 ="小毛驢";
System.out.println("s1==s2 "+(s1 == s2));
System.out.println("s1==s3 "+(s1 == s3));
}
控制臺
s1==s2 true
s1==s3 false
如上控制臺輸出，s1==s2為true，其實s2是將s1的引用地址拷貝給自己，它們指向的是同一個內存地址。而s3則不一樣，s3引用地址的字符串是在常量池中生成的，s1引用的內存地址是在堆區中生成的，讓2個不同內存空間的地址進行比較肯定是不相同的。
3.4 使用+重載符
情景一：
String s1 = "小"+"毛驢";
String s2 ="小毛驢" ;
System.out.println("s1==s2 "+(s1==s2));//結果=true
分析：JVM對于字符串常量的"+"號連接，在程序編譯期，JVM就將常量字符串的"+"連接優化為s1="小毛驢"。所以上面的結果會返回true。如下圖所示：
情景二：
String s1 = new String("小毛驢")+"在唱歌";
String s2 = "小毛驢";
String s3 = s2+"在唱歌";
String s4 = "小毛驢在唱歌";
System.out.println(s1==s4);//結果=false
System.out.println(s1==s3);//結果=false
System.out.println(s3==s4);//結果=false
分析：上面說到對于字符串常量的"+"號連接會在程序編譯期被JVM優化，但是引用的值在程序編譯期間是無法被確定的。只能在程序執行期間動態分配地址然后將地址存儲到s1、s3中，所以上面的結果都是false。那么有什么辦法可以讓引用的值等于s4嗎？答案是有的，在s4前面使用intern方法。在s4前面使用intern方法。在s4前面使用intern方法總要的事情說三遍！！！
注：只有在JDK7之后結果才會返回true。
情景三：
String s1 = new String("小")+"毛驢";
s1.intern();
String s2 = "小毛驢";
System.out.println(s1==s2);//結果=true
分析：intern的作用是為每個唯一的字符序列生成一個且僅生成一個String引用，對于這段代碼String s1 = new String("小")+"毛驢";其實是在堆區重新創建了一個對象然后把對象地址給了s1，其中s1指向的內容是"小毛驢"，但是在常量池中是沒有"小毛驢"的。這時候使用了s1.intern()方法將"小毛驢"存儲到常量池中，然后返回值在常量池的地址。當s2再去常量池中創建這個值的時候發現已經存在了就直接返回這個值的地址給s2，所以結果是true
情景四：
String s1 = "小毛驢";
final String s2 = "毛驢";
String s3 = "小" + s2;
System.out.println(s1 == s3); //結果 = true
分析：和情景2唯一不同的是s2使用了final修飾，對于final修飾的變量，它在編譯時被解析為常量值的一個本地拷貝存儲到自己的常量池中或 嵌入到它的字節碼流中。所以此時"小"+s2和"小"+"毛驢"效果是一樣的。
情景五：
String s1 = "小毛驢";
final String s2 = new String("毛驢");
String s3 = "小" + s2;
System.out.println(s1 == s3); //結果 = false
分析：和情景四一樣都使用了final修飾，但是JVM對于new String("毛驢")在編譯期是無法確定的，和情景二一樣只有在實例化后才能將內存地址賦給s2，故結果是false。
3.4 使用+重載符
在Java編程思想一書中作者提到過編譯器對String s1 = "小"+"毛"+"驢";的優化，重點提到了編譯器自動引入了StringBuilder類，原因是因為效率更高一些。編譯器優化后的代碼如下：
String a = "小";
String b = "毛";
String c = "驢";
String s = a + b + c;
StringBuilder temp = new StringBuilder();
temp.append(a).append(b).append(c);
String s1 = temp.toString();
System.out.println(s==s1);//結果＝false
書中舉例說明不要隨意使用String對象，雖然編譯器會自動地優化性能。例子采用2種方式生成一個String。
方法一：
String s = "小毛驢";
for(int i = 0; i < 100; i++) {
s += "驢";
}
方法二：
StringBuilder builder = new StringBuilder();
String s = "小毛驢";
for(int i = 0;i < 100;i++){
builder.append("驢");
}
String s1 = builder.toString();
由于編譯器的性能優化會每次在for(){}循環里創建StringBuilder對象，每一次++就會創建一次對象，然后append后就扔掉。下次循環再到達時重新產生個StringBuilder對象，然后 append 字符串，如此循環直至結束。 如果我們直接采用 StringBuilder 對象進行 append 的話，我們可以節省 N - 1 次創建和銷毀對象的時間。所以對于在循環中要進行字符串連接的應用，一般都是多線程使用StringBuffer和單線程下使用StringBulider對象來進行append操作。
String、StringBuffer和StringBuilder之間的聯系和區別
他們之間的聯系和區別：
- 和String不一樣，StringBuffer和StringBuilder類的char value數組不是final修飾的
- 每一次修改value值，String返回的是一個新的對象，而StringBuffer和StringBuilder返回的是this
- 在多線程環境下，StringBuilder是不安全的，String和StringBuffer是安全的。
