每天都在用String，你真的瞭解嗎？
阿新 • • 發佈：2020-08-18
# 1.String概述
> `java.lang.String` 類代表字串。Java程式中所有的字串文字（例如"abc")都可以被看作是實現此類的例項
>
> String 中包括用於檢查各個字串的方法，比如用於比較字串，搜尋字串，提取子字串以及建立具有翻譯為大寫或小寫的所有字元的字串的副本。
# 2.String原始碼分析
## 2.1.String成員變數
```java
// String的屬性值，String的內容本質上是使用不可變的char型別的陣列來儲存的。
private final char value[];
/*String型別的hash值,hash是String例項化物件的hashcode的一個快取值，這是因為String物件經常被用來進行比較，如果每次比較都重新計算hashcode值的話，是比較麻煩的，儲存一個快取值能夠進行優化 */
private int hash; // Default to 0
//serialVersionUID為序列化ID
private static final long serialVersionUID = -6849794470754667710L;
//serialPersistentFields屬性用於指定哪些欄位需要被預設序列化
private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];
```
serialPersistentFields具體用法為：
```java
private static final ObjectStreamField[] serialPersistentFields = {
new ObjectStreamField("name", String.class),
new ObjectStreamField("age", Integer.Type)
}
```
transient用於指定哪些欄位不會被預設序列化，兩者同時使用時，transient會被忽略。
在 Java 9 及之後，String 類的實現改用 byte 陣列儲存字串，同時使用 `coder`來標識使用了哪種字符集編碼。
```java
public final class String
implements java.io.Serializable, Comparable, CharSequence {
/** The value is used for character storage. */
private final byte[] value;
/** The identifier of the encoding used to encode the bytes in {@code value}. */
private final byte coder;
}
```
## 2.2.String構造方法
1、空參構造
```java
/**
* final宣告的 value陣列不能修改它的引用，所以在建構函式中一定要初始化value屬性
*/
public String() {
this.value = "".value;
}
```
2、用一個String來構造
```java
// 初始化一個新建立的 String 物件，使其表示一個與引數相同的字元序列；換句話說，新建立的字串是該引數字串的副本。
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
```
3、使用char陣列構造
```java
// 分配一個新的 String，使其表示字元陣列引數中當前包含的字元序列。
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}
// 分配一個新的 String，它包含取自字元陣列引數一個子陣列的字元。
public String(char value[], int offset, int count)
```
4、使用int陣列構造
```java
// 分配一個新的 String，它包含 Unicode 程式碼點陣列引數一個子陣列的字元。
public String(int[] codePoints, int offset, int count)
```
5、使用byte陣列構造
```java
// 通過使用平臺的預設字符集解碼指定的 byte 陣列，構造一個新的 String。
public String(byte bytes[])
// 通過使用平臺的預設字符集解碼指定的 byte 陣列，構造一個新的 String。
public String(byte[] bytes)
// 通過使用指定的 charset 解碼指定的 byte 陣列，構造一個新的 String。
public String(byte[] bytes, Charset charset)
// 通過使用平臺的預設字符集解碼指定的 byte 子陣列，構造一個新的 String。
public String(byte[] bytes, int offset, int length)
// 通過使用指定的 charset 解碼指定的 byte 子陣列，構造一個新的 String。
public String(byte[] bytes, int offset, int length, Charset charset)
// 通過使用指定的字符集解碼指定的 byte 子陣列，構造一個新的 String。
public String(byte[] bytes, int offset, int length, String charsetName)
//通過使用指定的 charset 解碼指定的 byte 陣列，構造一個新的 String。
public String(byte[] bytes, String charsetName)
```
6、使用StringBuffer或者StringBuilder構造
```java
//分配一個新的字串，它包含字串緩衝區引數中當前包含的字元序列。
public String(StringBuffer buffer)
// 分配一個新的字串，它包含字串生成器引數中當前包含的字元序列。
public String(StringBuilder builder)
```
# 3.字串常量池
作為最基礎的引用資料型別，Java 設計者為 String 提供了字串常量池以提高其效能，那麼字串常量池的具體原理是什麼？
## 3.1常量池的實現思想
- 字串的分配，和其他的物件分配一樣，耗費高昂的時間與空間代價，作為最基礎的資料型別，大量頻繁的建立字串，極大程度地影響程式的效能
- JVM為了提高效能和減少記憶體開銷，在例項化字串常量的時候進行了一些優化
- 為字串開闢一個字串常量池，類似於快取區
- 建立字串常量時，首先檢視字串常量池是否存在該字串
- 存在該字串，返回引用例項，不存在，例項化該字串並放入池中
- 實現的基礎
- 實現該優化的基礎是因為字串是不可變的，可以不用擔心資料衝突進行共享
- 執行時例項建立的全域性字串常量池中有一個表，總是為池中每個唯一的字串物件維護一個引用,這就意味著它們一直引用著字串常量池中的物件，所以，在常量池中的這些字串不會被垃圾收集器回收
## 3.2常量池的記憶體位置
- 堆
- 儲存的是物件，每個物件都包含一個與之對應的class
- JVM只有一個堆區(heap)被所有執行緒共享，堆中不存放基本型別和物件引用，只存放物件本身
- 物件的由垃圾回收器負責回收，因此大小和生命週期不需要確定
- 棧
- 每個執行緒包含一個棧區，棧中只儲存基礎資料型別的物件和自定義物件的引用(不是物件)
- 每個棧中的資料(原始型別和物件引用)都是私有的
- 棧分為3個部分：基本型別變數區、執行環境上下文、操作指令區(存放操作指令)
- 資料大小和生命週期是可以確定的，當沒有引用指向資料時，這個資料就會自動消失
- 方法區
- 靜態區，跟堆一樣，被所有的執行緒共享
- 方法區中包含的都是在整個程式中永遠唯一的元素，如class，static變數
**字串常量池則存在於方法區**
## 3.3案例分析
```java
String str1 = "abc";
String str2 = "abc";
String str3 = "abc";
String str4 = new String("abc");
String str5 = new String("abc");
String str6 = new String("abc");
```
變數str1到str6的記憶體分佈如圖所示；str1 = "abc"會先去常量池中看有沒有abc，如果有則引用這個字串，沒有則建立一個；str2和str3都是直接引用常量池中的abc；
String str4 = new String("abc") 這段程式碼會做兩步操作，第一步在常量池中查詢是否有"abc"物件，有則返回對應的引用例項，沒有則建立對應的例項物件；在堆中new一個String("abc")物件，將物件地址賦值給Str4，建立一個引用。
# 4.String記憶體分析
我們先來看一段程式碼
```java
public class TestString {
public static void main(String[] args) {
String str1 = "wugongzi";
String str2 = new String("wugongzi");
String str3 = str2; //引用傳遞，str3直接指向st2的堆記憶體地址
String str4 = "wugongzi";
/**
* ==:
* 基本資料型別：比較的是基本資料型別的值是否相同
* 引用資料型別：比較的是引用資料型別的地址值是否相同
* 所以在這裡的話：String類物件==比較，比較的是地址，而不是內容
*/
System.out.println(str1==str2);//false
System.out.println(str1==str3);//false
System.out.println(str3==str2);//true
System.out.println(str1==str4);//true
}
}
```
下面我們來分析一下這段程式碼的記憶體分佈
第一步：String str1 = "wugongzi" ，首先會去常量池中看有沒有wugongzi，發現沒有，則在常量池中建立了一個wugongzi，然後將wugongzi的記憶體地址賦值給str1；
第二步：String str2 = new String("wugongzi")，這段程式碼因為new了一個String物件，它首先常量池中查詢是否有wugongzi，發現已經有了，則返回對應的引用例項；然後再去堆中new一個String("wugongzi")物件，將物件地址賦值給Str2，建立一個引用。
第三步：String str3 = str2，// 引用傳遞，str3直接指向st2的堆記憶體地址；
第四步：String str4 = "wugongzi"，同第一步
# 5.String常用方法
## 5.1.equals方法
這裡重寫了Object中的equals方法，用來判斷兩個物件實際意義上是否相等，也就是值是否相等
```java
public boolean equals(Object anObject) {
//如果引用的是同一個物件，則返回真
if (this == anObject) {
return true;
}
//如果不是String型別的資料，返回假
if (anObject instanceof String) {
String anotherString = (String) anObject;
int n = value.length;
//如果char陣列長度不相等，返回假
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;
}
```
## 5.2.compareTo方法
用於比較兩個字串的大小，如果兩個字串長度相等則返回0，如果長度不相等，則返回當前字串的長度減去被比較的字串的長度。
```java
public int compareTo(String anotherString) {
//自身物件字串長度len1
int len1 = value.length;
//被比較物件字串長度len2
int len2 = anotherString.value.length;
//取兩個字串長度的最小值lim
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
//從value的第一個字元開始到最小長度lim處為止，如果字元不相等，返回自身（物件不相等處字元-被比較物件不相等字元）
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
//如果前面都相等，則返回（自身長度-被比較物件長度）
return len1 - len2;
}
```
## 5.3.hashCode方法
這裡重寫了hashCode方法，採用多項式進行計算，可以通過不同的字串得到相同的hash,所以兩個String物件的hashCode相同，並不代表兩個String是相同的。
演算法：假設n = 3
i=0 ->