JDK源碼解析之 Java.lang.String

String 類代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作為此類的實例實現。
字符串是常量；它們的值在創建之后不能更改。字符串緩沖區支持可變的字符串。因為 String 對象是不可變的，所以可以共享。

一、類定義

public final class Stringimplements java.io.Serializable, Comparable<String>, CharSequence{...}

實現的三個接口：

java.io.Serializable：可被序列化的標志接口
Comparable：強行對實現它的每個類的對象進行整體排序
CharSequence：用來表示一個有序字符的集合

String類是一個被final修飾的常量類，常量類的特性為不可被任何類所繼承，一旦String對象被創建，該對象是無法被改變的，直至該對象被銷毀（特殊情況除外：如暴力反射）。

二、成員變量

//存儲字段串
private final char value[];//緩存哈希值
private int hash; // Default to 0//用于序列化和反序列化之間的ID比對
private static final long serialVersionUID = -6849794470754667710L;//Class String is special cased within the Serialization Stream Protocol.
private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];

從源碼看出String底層使用一個字符數組來維護的。通過成員變量可以知道 String類的值是 final 類型的，不能被改變的，所以只要一個值改變就會生成一個新的 String 類型對象，存儲 String 數據也不一定從數組的第0個元素開始的，而是從 offset 所指的元素開始。

三、構造方法

//初始化一個新創建的 String 對象，使其表示一個空字符序列。 
public String() {
}//初始化一個新創建的 String 對象，使其表示一個與參數相同的字符序列；換句話說，新創建的字符串是該參數字符串的副本。
public String(String original) {
}//分配一個新的 String，使其表示字符數組參數中當前包含的字符序列。
public String(char value[]) {
}//分配一個新的 String，它包含取自字符數組參數一個子數組的字符。 
public String(char value[], int offset, int count) {
}//分配一個新的 String，它包含 Unicode 代碼點數組參數一個子數組的字符。
public String(int[] codePoints, int offset, int count) {
}@Deprecated
public String(byte ascii[], int hibyte, int offset, int count) {
}@Deprecated
public String(byte ascii[], int hibyte) {
}//通過使用指定的字符集解碼指定的 byte 子數組，構造一個新的 String。
public String(byte bytes[], int offset, int length, String charsetName)throws UnsupportedEncodingException {
}//通過使用指定的 charset 解碼指定的 byte 子數組，構造一個新的 String。 
public String(byte bytes[], int offset, int length, Charset charset) {
}//通過使用指定的 charset 解碼指定的 byte 數組，構造一個新的 String。 
public String(byte bytes[], String charsetName)throws UnsupportedEncodingException {
}//通過使用指定的 charset 解碼指定的 byte 數組，構造一個新的 String。
public String(byte bytes[], Charset charset) {
}//通過使用平臺的默認字符集解碼指定的 byte 子數組，構造一個新的 String。
public String(byte bytes[], int offset, int length) {
}//通過使用平臺的默認字符集解碼指定的 byte 數組，構造一個新的 String。 
public String(byte bytes[]) {
}//分配一個新的字符串，它包含字符串緩沖區參數中當前包含的字符序列。
public String(StringBuffer buffer) {
}//分配一個新的字符串，它包含字符串生成器參數中當前包含的字符序列。
public String(StringBuilder builder) {
}/*
* Package private constructor which shares value array for speed.
* this constructor is always expected to be called with share==true.
* a separate constructor is needed because we already have a public
* String(char[]) constructor that makes a copy of the given char[].
*/
String(char[] value, boolean share) {
}

四、普通方法

1、equals(Object anObject)方法

比較字符串的內容是否相同

 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;}

String類里重寫了Object里的equals方法，首先比較對象地址判斷是否是兩個相等的對象，若不相等再通過instanceof關鍵字比對傳入對象是否是String的實例，若是則一一比對字符串的每一個字符;

2、hashCode()方法

String類的hashCode算法很簡單，使用數字31作為乘數;

   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;
}

3、charAt(int index) 方法

該方法的作用是得到字符串的指定索引位置的字符元素;

public char charAt(int index) {if ((index < 0) || (index >= value.length)) {throw new StringIndexOutOfBoundsException(index);}return value[index];
}

4、compareTo(String anotherString)方法

該方法是按字母順序比較兩個字符串中每個字符的 Unicode 值

 public int compareTo(String anotherString) {int len1 = value.length;int len2 = anotherString.value.length;int lim = Math.min(len1, len2);char v1[] = value;char v2[] = anotherString.value;int k = 0;while (k < lim) {char c1 = v1[k];char c2 = v2[k];if (c1 != c2) {return c1 - c2;}k++;}return len1 - len2;
}

當兩個字符串某個位置的字符不同時，返回的是這一位置的字符 Unicode 值之差，當兩個字符串都相同時，返回兩個字符串長度之差。此外還有個compareToIgnoreCase()方法，該方法是在 compareTo() 方法的基礎上忽略大小寫。

5、concat(String str)方法

該方法的作用的將指定字符串拼接到原字符串末尾

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);}

首先判斷要拼接字符串長度，若長度為0則返回原字符串，不為0則利用工具類Arrays中的靜態方法copyOf來構建一個長度為原字符串和要拼接字符串的之和的字符數組，并將原字符串填充到字符數組前面，后面為空，再利用getChars方法將要拼接字符串放入字符數組后面為空的位置，最后返回一個拼接后的新字符串。

6、indexOf(int ch, int fromIndex) 方法

該方法的作用是從指定索引位置開始查找指定字符第一次出現的位置

public int indexOf(int ch, int fromIndex) {final int max = value.length;// 指定索引值小于0，默認從0開始搜索if (fromIndex < 0) {fromIndex = 0;} else if (fromIndex >= max) {// 指定索引值大于等于字符串長度，直接返回-1return -1;}// 一個char占用兩個字節，如果ch小于2的16次方（65536），絕大多數字符都在此范圍內if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {final char[] value = this.value;for (int i = fromIndex; i < max; i++) {if (value[i] == ch) {return i;}}return -1;} else {//當字符大于 65536時，處理的少數情況，該方法會首先判斷是否是有效字符，然后依次進行比較return indexOfSupplementary(ch, fromIndex);}}

首先進行一系列的邏輯判斷，最后for循環逐一判斷對比，相等返回下標索引值，循環結束沒有相等的就返回-1。

7、split(String regex, int limit) 方法

該方法的作用是將字符串分隔成指定正則表達式匹配后的字符串數組

   public String[] split(String regex, int limit) {/* 1、單個字符，且不是".$|()[{^?*+\\"其中一個* 2、兩個字符，第一個是"\"，第二個大小寫字母或者數字*/char ch = 0;if (((regex.value.length == 1 &&".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||(regex.length() == 2 &&regex.charAt(0) == '\\' &&(((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&((ch-'a')|('z'-ch)) < 0 &&((ch-'A')|('Z'-ch)) < 0)) &&(ch < Character.MIN_HIGH_SURROGATE ||ch > Character.MAX_LOW_SURROGATE)){int off = 0;int next = 0;boolean limited = limit > 0;//大于0，limited==true,反之limited==falseArrayList<String> list = new ArrayList<>();while ((next = indexOf(ch, off)) != -1) {//當參數limit<=0 或者 集合list的長度小于 limit-1if (!limited || list.size() < limit - 1) {list.add(substring(off, next));off = next + 1;} else {//判斷最后一個list.size() == limit - 1list.add(substring(off, value.length));off = value.length;break;}}//如果沒有一個能匹配的，返回一個新的字符串，內容和原來的一樣if (off == 0)return new String[]{this}; // 當 limit<=0 時，limited==false,或者集合的長度 小于 limit是，截取添加剩下的字符串if (!limited || list.size() < limit)list.add(substring(off, value.length));// 當 limit == 0 時，如果末尾添加的元素為空（長度為0），則集合長度不斷減1，直到末尾不為空int resultSize = list.size();if (limit == 0) {while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {resultSize--;}}String[] result = new String[resultSize];return list.subList(0, resultSize).toArray(result);
}
return Pattern.compile(regex).split(this, limit);
}

limit的取值存在三種情況：

limit>0，拆分limit-1次

String str = "a,b,c";
String[] c1 = str.split(",", 2);
System.out.println(c1.length);//2
System.out.println(Arrays.toString(c1));//{"a","b,c"}
1234

limit=0,拆分無限次且忽略原字符串后面的空白部分

String str = "a,b,c,,";
String[] c1 = str.split(",", 0);
System.out.println(c1.length);//3
System.out.println(Arrays.toString(c1));//{"a","b","c"}
1234

limit<0,拆分無限次

String str = "a,b,c,,";
String[] c1 = str.split(",", 0);
System.out.println(c1.length);//5
System.out.println(Arrays.toString(c1));//{"a","b","c","",""}

8、String replaceAll(String regex, String replacement) 方法

該方法的作用是將原字符串中符合正則表達式的都替換成指定的字符串

 public String replaceAll(String regex, String replacement) {return Pattern.compile(regex).matcher(this).replaceAll(replacement);}

此外還有個replace(char oldChar, char newChar)方法，作用是將所有olfChar都替換成newCher。

9、substring(int beginIndex, int endIndex) 方法

該方法的作用是返回從索引 beginIndex 到 endIndex 的子字符串

public String substring(int beginIndex, int endIndex) {if (beginIndex < 0) {//起始索引小于0拋出異常throw new StringIndexOutOfBoundsException(beginIndex);}if (endIndex > value.length) {//起始索引大于字符串長度拋出異常throw new StringIndexOutOfBoundsException(endIndex);}int subLen = endIndex - beginIndex;//起始索引大于截止索引拋出異常if (subLen < 0) {throw new StringIndexOutOfBoundsException(subLen);}return ((beginIndex == 0) && (endIndex == value.length)) ? this: new String(value, beginIndex, subLen);}
123456789101112131415

此外還有個重載方法substring(int beginIndex)，作用是返回從索引 beginIndex 開始一直到結尾的子字符串。

五、拓展

1、常量池

JVM里有一塊區域叫做常量池，常量池中的數據是那些在編譯期間被確定，并被保存在已編譯的.class文件中的一些數據。除了包含所有的8種基本數據類型（char、byte、short、int、long、float、double、boolean）外，還有String及其數組的常量值，另外還有一些以文本形式出現的符號引用。

我們聲明字符串對象有兩種常用的方式：

通過"字面值"的形式直接賦值

String str="abc";

通過構造函數構建對象

String str=new String("abc");

那么這兩種方式有什么區別呢？我們來測試一下：

String str1 = "hello";
String str2 = "hello";
String str3 = new String("hello");
String str4 = new String("hello");
System.out.println(str1==str2);//true
System.out.println(str1==str3);//fasle
System.out.println(str3==str4);//fasle

通過上面這個例子充分說明了以下規律：

①、字面量創建字符串會先在字符串池中找，看是否有相等的對象，沒有的話就在字符串池創建該對象；有的話則直接用池中的引用，避免重復創建對象。
②、new關鍵字創建時，直接在堆中創建一個新對象，變量所引用的都是這個新對象的地址。

實際在日常我們也很經常用表達式來拼接字符串，這些的字符串對象又是怎么得到的呢？

String str1 = "hello";
String str2 = "helloworld";
String str3 = str1+"world";//編譯器不能確定為常量(會在堆區創建一個String對象)
String str4 = "hello"+"world";//編譯器確定為常量，直接到常量池中引用
System.out.println(str2==str3);//fasle
System.out.println(str2==str4);//true
System.out.println(str3==str4);//fasle

從開頭我們可以知道常量池保存的是在編譯期間被確定一些數據，這些數據絕對不能是變量，因此我們可以很清楚的知道上面的這些例子為什么是這樣的結果了。

2、關于String不可變

從開始我們就知道String類被final修飾，因此我們把它當做是不可變對象，它的值是同樣被final修飾的字符數組：

private final char value[];

在java 中使用字符串最重要的一個規則必須記住，一個字符串對象一旦被創建，它的內容就是固定不變的

 public static String str = "abc";

這個聲明會創建一個長度為3，內容為abc的字符串對象，您無法改變這個字符串對象的內容。

str = "1111";

不要以為這樣就改變了字符串對象的內容,事實上。上面那段代碼中產生了兩個字符串對象，一個是abc字符串對象，長度為3；一個是1111字符串對象，長度為4，兩個不同的字符串對象。您不不是在abc 字符串改為1111字符串，而是讓str 引用名稱從新引用1111字符串，而不在引用abc 字符串但abc字符串在內存中還是存在的，只是現在沒有被引用。

String類為什么要被設置成不可變呢？

安全
- 引發安全問題，譬如，數據庫的用戶名、密碼都是以字符串的形式傳入來獲得數據庫的連接，或者在socket編程中，主機名和端口都是以字符串的形式傳入。因為字符串是不可變的，所以它的值是不可改變的，否則黑客們可以鉆到空子，改變字符串指向的對象的值，造成安全漏洞。
- 保證線程安全，在并發場景下，多個線程同時讀寫資源時，會引競態條件，由于 String 是不可變的，不會引發線程的問題而保證了線程。
- HashCode，當 String 被創建出來的時候，hashcode也會隨之被緩存，hashcode的計算與value有關，若 String 可變，那么 hashcode 也會隨之變化，針對于 Map、Set 等容器，他們的鍵值需要保證唯一性和一致性，因此，String 的不可變性使其比其他對象更適合當容器的鍵值。
性能
- 當字符串是不可變時，字符串常量池才有意義。字符串常量池的出現，可以減少創建相同字面量的字符串，讓不同的引用指向池中同一個字符串，為運行時節約很多的堆內存。若字符串可變，字符串常量池失去意義，基于常量池的String.intern()方法也失效，每次創建新的 String 將在堆內開辟出新的空間，占據更多的內存。