Tip：筆者馬上畢業了，準備開始 Java 的進階學習計劃。於是打算先從 String 類的原始碼分析入手，作為後面學習的案例。這篇文章寄託著今後進階系列產出的願望，希望能堅持下去，不忘初心，讓自己保持那份對技術的熱愛。
因為學習分析原始碼，所以借鑑了 HollisChuang 成神之路的大部分內容，並在此基礎上對原始碼進行了學習，在此感謝。
問題的引入
關於 String 字串，對於Java開發者而言，這無疑是一個非常熟悉的類。也正是因為經常使用，其內部程式碼的設計才值得被深究。所謂知其然，更得知其所以然。
舉個例子，假如想要寫個類去繼承 String，這時 IDE 提示 String 為final型別不允許被繼承。
此時最先想到的肯定是 java 中類被 final 修飾的效果，其實由這一點也可以引出更多思考： 比如說 String 類被設計成 final 型別是出於哪些考慮？
在Java中，被 final 型別修飾的類不允許被其他類繼承，被 final 修飾的變數賦值後不允許被修改
定義
檢視 String 類在 JDK 7 原始碼中的定義：
public final class String implements java.io.Serializable, Comparable<String>, CharSequence{
...
}
複製程式碼可以看出 String 是 final 型別的，表示該類不能被其他類繼承，同時該類實現了三個介面：java.io.Serializable Comparable<String> CharSequence
對於 Sting 類，官方有如下注釋說明：
/*
Strings are constant;
their values can not be changed after they are created.
Stringbuffers support mutable strings.
Because String objects are immutable they can be shared. Forexample:
*/
複製程式碼String 字串是常量，其值在例項建立後就不能被修改，但字串緩衝區支援可變的字串，因為緩衝區裡面的不可變字串物件們可以被共享。（其實就是使物件的引用發生了改變）
屬性
/**
The value isused for character storage.
*/
private final char value[];
複製程式碼這是一個字元陣列，並且是 final 型別，用於儲存字串內容。從 fianl 關鍵字可以看出，String 的內容一旦被初始化後，其不能被修改的。
看到這裡也許會有人疑惑，String 初始化以後好像可以被修改啊。比如找一個常見的例子：
String str = “hello”; str = “hi”其實這裡的賦值並不是對 str 內容的修改，而是將str指向了新的字串。另外可以明確的一點：String 其實是基於字元陣列 char[] 實現的。
下面再來看 String 其他屬性： 比如快取字串的 hash Code，其預設值為 0：
/**
Cache the hashcode for the string
*/
private int hash; //Default to 0
複製程式碼關於序列化 serialVersionUID：
/**
use serialVersionUID from JDK 1.0.2 for interoperability
*/
private static final long serialVersionUID = -6849794470754667710L;
/**
Class String is special cased with in the Serialization Stream Protocol.
*/
privates tatic final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0]
複製程式碼因為 String 實現了 Serializable 介面，所以支援序列化和反序列化支援。Java 的序列化機制是通過在執行時判斷類的 serialVersionUID 來驗證版本一致性的。在進行反序列化時，JVM 會把傳來的位元組流中的 serialVersionUID 與本地相應實體（類）的 serialVersionUID 進行比較，如果相同就認為是一致的，可以進行反序列化，否則就會出現序列化版本不一致的異常 (InvalidCastException)。
構造方法
空的構造器
public String(){
this.value = "".value;
}
複製程式碼該構造方法會建立空的字元序列，注意這個構造方法的使用，因為創造不必要的字串物件是不可變的。因此不建議採取下面的建立 String 物件:
String str = new String()
str = "sample";
複製程式碼這樣的結果顯而易見，會產生了不必要的物件。
使用字串型別的物件來初始化
public String(String original){
this.value = original.value;
this.hash = original.hash;
}
複製程式碼這裡將直接將源 String 中的 value 和 hash 兩個屬性直接賦值給目標 String。因為 String 一旦定義之後是不可以改變的，所以也就不用擔心改變源 String 的值會影響到目標 String 的值。
使用字元陣列來構造
public String(char value[]){
this.value = Arrays.copyOf(value, value.length);
}
複製程式碼public String(char value[], int offset, int count){
if(offset<0){
throw new StringIndexOutOfBoundsException(offset);
}
if(count<=0){
if(count<0){
throw new String IndexOutOfBoundsException(count);
}
if(offset <= value.length){
this.value = "".value;
return;
}
}
//Note:offset or count might be near-1>>>1.
if(offset > value.length - count){
throw new StringIndexOutOfBoundsException(offset+count);
}
this.value=Arrays.copyOfRange(value,offset,offset+count);
}
複製程式碼這裡值得注意的是：當我們使用字元陣列建立 String 的時候，會用到 Arrays.copyOf 方法或 Arrays.copyOfRange 方法。這兩個方法是將原有的字元陣列中的內容逐一的複製到 String 中的字元陣列中。會建立一個新的字串物件，隨後修改的字元陣列不影響新建立的字串。
使用位元組陣列來構建 String
在 Java 中，String 例項中儲存有一個 char[] 字元陣列，char[] 字元陣列是以 unicode 碼來儲存的，String 和 char 為記憶體形式。
byte 是網路傳輸或儲存的序列化形式，所以在很多傳輸和儲存的過程中需要將 byte[] 陣列和 String 進行相互轉化。所以 String 提供了一系列過載的構造方法來將一個字元陣列轉化成 String，提到 byte[] 和 String 之間的相互轉換就不得不關注編碼問題。
String(byte[] bytes, Charset charset)
複製程式碼該構造方法是指通過 charset 來解碼指定的 byte 陣列，將其解碼成 unicode 的 char[] 陣列，構造成新的 String。
這裡的 bytes 位元組流是使用 charset 進行編碼的，想要將他轉換成 unicode 的 char[] 陣列，而又保證不出現亂碼，那就要指定其解碼方式
同樣的，使用位元組陣列來構造 String 也有很多種形式，按照是否指定解碼方式分的話可以分為兩種：
public String(byte bytes[]){
this(bytes, 0, bytes.length);
}
複製程式碼public String(byte bytes[], int offset, int length){
checkBounds(bytes, offset, length);
this.value = StringCoding.decode(bytes, offset, length);
}
複製程式碼如果我們在使用 byte[] 構造 String 的時候，使用的是下面這四種構造方法（帶有 charsetName 或者 charset 引數）的一種的話，那麼就會使用 StringCoding.decode 方法進行解碼，使用的解碼的字符集就是我們指定的 charsetName 或者 charset。
String(byte bytes[])
String(byte bytes[], int offset, int length)
String(byte bytes[], Charset charset)
String(byte bytes[], String charsetName)
String(byte bytes[], int offset, int length, Charset charset)
String(byte bytes[], int offset, int length, String charsetName)
複製程式碼我們在使用 byte[] 構造 String 的時候，如果沒有指明解碼使用的字符集的話，那麼 StringCoding 的 decode 方法首先呼叫系統的預設編碼格式，如果沒有指定編碼格式則預設使用 ISO-8859-1 編碼格式進行編碼操作。主要體現程式碼如下：
static char[] decode(byte[] ba, int off, int len){
String csn = Charset.defaultCharset().name();
try{ //use char set name decode() variant which provide scaching.
return decode(csn, ba, off, len);
} catch(UnsupportedEncodingException x){
warnUnsupportedCharset(csn);
}
try{
return decode("ISO-8859-1", ba, off, len); }
catch(UnsupportedEncodingException x){
//If this code is hit during VM initiali zation, MessageUtils is the only way we will be able to get any kind of error message.
MessageUtils.err("ISO-8859-1 char set not available: " + x.toString());
// If we can not find ISO-8859-1 (are quired encoding) then things are seriously wrong with the installation.
System.exit(1);
return null;
}
}
複製程式碼使用 StringBuffer 和 StringBuilder 構造一個 String 作為 String 的兩個“兄弟”，StringBuffer 和 StringBuilder 也可以被當做構造 String 的引數。
public String(StringBuffer buffer) {
synchronized(buffer) {
this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
}
}
public String(StringBuilder builder) {
this.value = Arrays.copyOf(builder.getValue(), builder.length());
}
複製程式碼當然，這兩個構造方法是很少用到的，因為當我們有了 StringBuffer 或者 StringBuilfer 物件之後可以直接使用他們的 toString 方法來得到 String。
關於效率問題，Java 的官方文件有提到說使用StringBuilder 的 toString 方法會更快一些，原因是 StringBuffer 的 toString 方法是 synchronized 的，在犧牲了效率的情況下保證了執行緒安全。
StringBuilder 的 toString() 方法：
@Override
public String toString(){
//Create a copy, don't share the array
return new String(value,0,count);
}
複製程式碼StringBuffer 的 toString() 方法：
@Override
public synchronized String toString(){
if (toStringCache == null){
toStringCache = Arrays.copyOfRange(value, 0, count);
}
return new String(toStringCache, true);
}
複製程式碼一個特殊的保護型別的構造方法 String 除了提供了很多公有的供程式設計師使用的構造方法以外，還提供了一個保護型別的構造方法（Java 7），我們看一下他是怎麼樣的：
String(char[] value, boolean share) {
// assert share : "unshared not supported";
this.value = value;
}
複製程式碼從程式碼中我們可以看出，該方法和 String(char[] value) 有兩點區別：
-
第一個區別：該方法多了一個引數：boolean share，其實這個引數在方法體中根本沒被使用。註釋說目前不支援 false，只使用 true。那可以斷定，加入這個 share 的只是為了區分於 String(char[] value) 方法，不加這個引數就沒辦法定義這個函式，只有引數是不同才能進行過載。
-
第二個區別：具體的方法實現不同。我們前面提到過 String(char[] value) 方法在建立 String 的時候會用到 Arrays 的 copyOf 方法將 value 中的內容逐一複製到 String 當中，而這個 String(char[] value, boolean share) 方法則是直接將 value 的引用賦值給 String 的 value。那麼也就是說，這個方法構造出來的 String 和引數傳過來的 char[] value 共享同一個陣列。
為什麼 Java 會提供這樣一個方法呢？
-
**效能好：**這個很簡單，一個是直接給陣列賦值（相當於直接將 String 的 value 的指標指向char[]陣列），一個是逐一拷貝，當然是直接賦值快了。
-
**節約記憶體：**該方法之所以設定為 protected，是因為一旦該方法設定為公有，在外面可以訪問的話，如果構造方法沒有對 arr 進行拷貝，那麼其他人就可以在字串外部修改該陣列，由於它們引用的是同一個陣列，因此對 arr 的修改就相當於修改了字串，那就破壞了字串的不可變性。
-
**安全的：**對於呼叫他的方法來說，由於無論是原字串還是新字串，其 value 陣列本身都是 String 物件的私有屬性，從外部是無法訪問的，因此對兩個字串來說都很安全。
Java 7 加入的新特性
在 Java 7 之前有很多 String 裡面的方法都使用上面說的那種“效能好的、節約記憶體的、安全”的建構函式。
比如：substring replace concat valueOf 等方法
實際上它們使用的是 public String(char[], ture) 方法來實現。
但是在 Java 7 中，substring 已經不再使用這種“優秀”的方法了
public String substring(int beginIndex, int endIndex){
if(beginIndex < 0){
throw new StringIndexOutOfBoundsException(beginIndex);
}
if(endIndex > value.length){
throw new StringIndexOutOfBoundsException(endIndex);
}
intsubLen = endIndex-beginIndex;
if(subLen < 0){
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this : newString(value, beginIndex, subLen);
}
複製程式碼為什麼呢？ 雖然這種方法有很多優點，但是他有一個致命的缺點，對於 sun 公司的程式設計師來說是一個零容忍的 bug，那就是他很有可能造成記憶體洩露。
看一個例子，假設一個方法從某個地方（檔案、資料庫或網路）取得了一個很長的字串，然後對其進行解析並提取其中的一小段內容，這種情況經常發生在網頁抓取或進行日誌分析的時候。
下面是示例程式碼：
String aLongString = "...averylongstring...";
String aPart = data.substring(20, 40);
return aPart;
複製程式碼在這裡 aLongString 只是臨時的，真正有用的是 aPart，其長度只有 20 個字元，但是它的內部陣列卻是從 aLongString 那裡共享的，因此雖然 aLongString 本身可以被回收，但它的內部陣列卻不能釋放。這就導致了記憶體洩漏。如果一個程式中這種情況經常發生有可能會導致嚴重的後果，如記憶體溢位，或效能下降。
新的實現雖然損失了效能，而且浪費了一些儲存空間，但卻保證了字串的內部陣列可以和字串物件一起被回收，從而防止發生記憶體洩漏，因此新的 substring 比原來的更健壯。
其他方法
length() 返回字串長度
public int length(){
return value.length;
}
複製程式碼isEmpty() 返回字串是否為空
public boolean isEmpty(){
return value.length == 0;
}
複製程式碼charAt(int index) 返回字串中第（index+1）個字元（陣列索引）
public char charAt(int index){
if((index < 0) || (index >= value.length)){
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}
複製程式碼char[] toCharArray() 轉化成字元陣列
trim()去掉兩端空格
toUpperCase()轉化為大寫
toLowerCase()轉化為小寫
需要注意
String concat(String str) 拼接字串
String replace(char oldChar, char newChar) 將字串中的
oldChar 字元換成 newChar 字元
以上兩個方法都使用了
String(char[] value, boolean share)concat 方法和 replace 方法，他們不會導致元陣列中有大量空間不被使用，因為他們一個是拼接字串，一個是替換字串內容，不會將字元陣列的長度變得很短，所以使用了共享的 char[] 字元陣列來優化。
boolean matches(String regex) 判斷字串是否匹配給定的regex正規表示式
boolean contains(CharSequence s) 判斷字串是否包含字元序列 s
String[] split(String regex, int limit) 按照字元 regex將字串分成 limit 份
String[] split(String regex) 按照字元 regex 將字串分段
getBytes
在建立 String 的時候，可以使用 byte[] 陣列，將一個位元組陣列轉換成字串，同樣，我們可以將一個字串轉換成位元組陣列，那麼 String 提供了很多過載的 getBytes 方法。
public byte[] getBytes(){
return StringCoding.encode(value, 0, value.length);
}
複製程式碼但是，值得注意的是，在使用這些方法的時候一定要注意編碼問題。比如：
String s = "你好，世界！"; byte[] bytes = s.getBytes();
這段程式碼在不同的平臺上執行得到結果是不一樣的。由於沒有指定編碼方式，所以在該方法對字串進行編碼的時候就會使用系統的預設編碼方式。
在中文作業系統中可能會使用 GBK 或者 GB2312 進行編碼，在英文作業系統中有可能使用 iso-8859-1 進行編碼。這樣寫出來的程式碼就和機器環境有很強的關聯性了，為了避免不必要的麻煩，要指定編碼方式。
public byte[] getBytes(String charsetName) throws UnsupportedEncodingException{
if (charsetName == null) throw new NullPointerException();
return StringCoding.encode(charsetName, value, 0, value.length);
}
複製程式碼比較方法
boolean equals(Object anObject)； 比較物件
boolean contentEquals(String Buffersb)； 與字串比較內容
boolean contentEquals(Char Sequencecs)； 與字元比較內容
boolean equalsIgnoreCase(String anotherString)；忽略大小寫比較字串物件
int compareTo(String anotherString)； 比較字串
int compareToIgnoreCase(String str)； 忽略大小寫比較字串
boolean regionMatches(int toffset, String other, int ooffset, int len)區域性匹配
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 可忽略大小寫區域性匹配
字串有一系列方法用於比較兩個字串的關係。 前四個返回 boolean 的方法很容易理解，前三個比較就是比較 String 和要比較的目標物件的字元陣列的內容，一樣就返回 true, 不一樣就返回false，核心程式碼如下：
int n = value.length;
while (n-- ! = 0) {
if (v1[i] != v2[i])
return false;
i++;
}
複製程式碼v1 v2 分別代表 String 的字元陣列和目標物件的字元陣列。 第四個和前三個唯一的區別就是他會將兩個字元陣列的內容都使用 toUpperCase 方法轉換成大寫再進行比較，以此來忽略大小寫進行比較。相同則返回 true，不想同則返回 false
equals方法：
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String) anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
複製程式碼該方法首先判斷 this == anObject ？，也就是說判斷要比較的物件和當前物件是不是同一個物件，如果是直接返回 true，如不是再繼續比較，然後在判斷 anObject 是不是 String 型別的，如果不是，直接返回 false，如果是再繼續比較，到了能終於比較字元陣列的時候，他還是先比較了兩個陣列的長度，不一樣直接返回 false，一樣再逐一比較值。 雖然程式碼寫的內容比較多，但是可以很大程度上提高比較的效率。值得學習！！！
StringBuffer 需要考慮執行緒安全問題，加鎖之後再呼叫
contentEquals 有兩個過載：
- contentEquals((CharSequence) sb) 方法
contentEquals((CharSequence) sb) 分兩種情況，一種是
cs instanceof AbstractStringBuilder，另外一種是引數是 String 型別。具體比較方式幾乎和 equals 方法類似，先做“巨集觀”比較，在做“微觀”比較。
下面這個是 equalsIgnoreCase 程式碼的實現：
public boolean equalsIgnoreCase(String anotherString) {
return (this == anotherString) ? true : (anotherString != null) && (anotherString.value.length == value.length) && regionMatches(true, 0, anotherString, 0, value.length);
}
複製程式碼看到這段程式碼，眼前為之一亮。使用一個三目運算子和 && 操作代替了多個 if 語句。
hashCode
public int hashCode(){
int h = hash;
if(h == 0 && value.length > 0){
char val[] = value;
for(int i = 0; i < value.length; i++){
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
複製程式碼hashCode 的實現其實就是使用數學公式：s[0] * 31^(n-1) + s[1] * 31^(n-2) + ... + s[n-1]
所謂“衝突”，就是在儲存資料計算 hash 地址的時候，我們希望儘量減少有同樣的 hash 地址。如果使用相同 hash 地址的資料過多，那麼這些資料所組成的 hash 鏈就更長，從而降低了查詢效率。
所以在選擇係數的時候要選擇儘量長的係數並且讓乘法儘量不要溢位的係數，因為如果計算出來的 hash 地址越大，所謂的“衝突”就越少，查詢起來效率也會提高。
現在很多虛擬機器裡面都有做相關優化，使用 31 的原因可能是為了更好的分配 hash 地址，並且 31 只佔用 5 bits。
在 Java 中，整型數是 32 位的，也就是說最多有 2^32 = 4294967296 個整數，將任意一個字串，經過 hashCode 計算之後，得到的整數應該在這 4294967296 數之中。那麼，最多有 4294967297 個不同的字串作 hashCode 之後，肯定有兩個結果是一樣的。
hashCode 可以保證相同的字串的 hash 值肯定相同，但是 hash 值相同並不一定是 value 值就相同。
substring 前面我們介紹過，java 7 中的 substring 方法使用 String(value, beginIndex, subLen) 方法建立一個新的 String 並返回，這個方法會將原來的 char[] 中的值逐一複製到新的 String 中，兩個陣列並不是共享的，雖然這樣做損失一些效能，但是有效地避免了記憶體洩露。
replaceFirst、replaceAll、replace區別
String replaceFirst(String regex, String replacement)
String replaceAll(String regex, String replacement)
String replace(Char Sequencetarget, Char Sequencereplacement)
public String replace(char oldChar, char newChar){
if(oldChar != newChar){
int len = value.length;
int i = -1;
char[] val = value; /*avoid get field opcode*/
while (++i < len){
if (val[i] == oldChar){
break;
}
}
if( i < len ){
char buf[] = new char[len];
for (intj=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;
}
複製程式碼- replace 的引數是 char 和 CharSequence，即可以支援字元的替換, 也支援字串的替換
- replaceAll 和 replaceFirst 的引數是 regex，即基於規則表示式的替換
比如可以通過 replaceAll (“\d”, “*”)把一個字串所有的數字字元都換成星號;
相同點是都是全部替換，即把源字串中的某一字元或字串全部換成指定的字元或字串，如果只想替換第一次出現的，可以使用 replaceFirst()，這個方法也是基於規則表示式的替換。另外,如果replaceAll() 和r eplaceFirst() 所用的引數據不是基於規則表示式的，則與replace()替換字串的效果是一樣的，即這兩者也支援字串的操作。
copyValueOf 和 valueOf String 的底層是由 char[] 實現的，早期的 String 構造器的實現呢，不會拷貝陣列的，直接將引數的 char[] 陣列作為 String 的 value 屬性。字元陣列將導致字串的變化。
為了避免這個問題，提供了 copyValueOf 方法，每次都拷貝成新的字元陣列來構造新的 String 物件。
現在的 String 物件，在構造器中就通過拷貝新陣列實現了，所以這兩個方面在本質上已經沒區別了。
valueOf()有很多種形式的過載，包括：
public static String valueOf(boolean b) {
return b ? "true" : "false";
}
public static String valueOf(char c) {
char data[] = {c};
return new String(data, true);
}
public static String valueOf(int i) {
return Integer.toString(i);
}
public static String valueOf(long l) {
return Long.toString(l);
}
public static String valueOf(float f) {
return Float.toString(f);
}
public static String valueOf(double d) {
return Double.toString(d);
}
複製程式碼可以看到這些方法可以將六種基本資料型別的變數轉換成 String 型別。
intern()方法
public native String intern(); 該方法返回一個字串物件的內部化引用。
String 類維護一個初始為空的字串的物件池，當 intern 方法被呼叫時，如果物件池中已經包含這一個相等的字串物件則返回物件池中的例項，否則新增字串到物件池並返回該字串的引用。
String 對 “+” 的過載
我們知道，Java 是不支援過載運算子，String 的 “+” 是 java 中唯一的一個過載運算子，那麼 java 使如何實現這個加號的呢？我們先看一段程式碼：
public static void main(String[] args) {
String string = "hello";
String string2 = string + "world";
}
複製程式碼然後我們將這段程式碼的實際執行情況貼出來看看：
public static void main(String args[]){
String string = "hollo";
String string2 = (new StringBuilder(String.valueOf(string))).append("world").toString();
}
複製程式碼看了反編譯之後的程式碼我們發現，其實 String 對 “+” 的支援其實就是使用了 StringBuilder 以及他的 append、toString 兩個方法。
String.valueOf和Integer.toString的區別 接下來我們看以下這段程式碼，我們有三種方式將一個 int 型別的變數變成呢過String型別，那麼他們有什麼區別？
int i = 5;
String i1 = "" + i;
String i2 = String.valueOf(i);
String i3 = Integer.toString(i);
複製程式碼第三行和第四行沒有任何區別，因為 String.valueOf(i) 也是呼叫 Integer.toString(i) 來實現的。 第二行程式碼其實是 String i1 = (new StringBuilder()).append(i).toString();
首先建立了一個 StringBuilder 物件，然後再呼叫 append 方法，再呼叫 toString 方法。
switch 對字串支援的實現
還是先上程式碼：
public class switchDemoString {
public static void main(String[] args) {
String str = "world";
switch (str) {
case "hello":
System.out.println("hello");
break;
case "world":
System.out.println("world");
break;
default: break;
}
}
}
複製程式碼對編譯後的程式碼進行反編譯：
public static void main(String args[]) {
String str = "world";
String s;
switch((s = str).hashCode()) {
case 99162322:
if(s.equals("hello"))
System.out.println("hello");
break;
case 113318802:
if(s.equals("world"))
System.out.println("world");
break;
default: break;
}
}
複製程式碼看到這個程式碼，你知道原來字串的 switch 是通過 equals() 和 hashCode() 方法來實現的。記住，switch 中只能使用整型，比如 byte，short，char(ackii碼是整型) 以及 int。還好 hashCode() 方法返回的是 int 而不是 long。
通過這個很容易記住 hashCode 返回的是 int 這個事實。仔細看下可以發現，進行 switch 的實際是雜湊值，然後通過使用 equals 方法比較進行安全檢查，這個檢查是必要的，因為雜湊可能會發生碰撞。
因此效能是不如使用列舉進行 switch 或者使用純整數常量，但這也不是很差。因為 Java 編譯器只增加了一個 equals 方法，如果你比較的是字串字面量的話會非常快，比如 ”abc” ==”abc” 。如果你把 hashCode() 方法的呼叫也考慮進來了，那麼還會再多一次的呼叫開銷，因為字串一旦建立了，它就會把雜湊值快取起來。 因此如果這個 siwtch 語句是用在一個迴圈裡的，比如逐項處理某個值，或者遊戲引擎迴圈地渲染螢幕，這裡 hashCode() 方法的呼叫開銷其實不會很大。
其實 swich 只支援一種資料型別，那就是整型，其他資料型別都是轉換成整型之後在使用 switch 的。
總結
- 一旦 String 物件在記憶體(堆)中被建立出來，就無法被修改。
特別要注意的是，String 類的所有方法都沒有改變字串本身的值，都是返回了一個新的物件。
- 如果你需要一個可修改的字串，應該使用 StringBuffer 或者 StringBuilder。
否則會有大量時間浪費在垃圾回收上，因為每次試圖修改都有新的String 物件被建立出來。
- 如果你只需要建立一個字串，你可以使用雙引號的方式，如果你需要在堆中建立一個新的物件，你可以選擇建構函式的方式。