Java深入淺出之String

String 是如何實現的？它有哪些重要的方法？

以主流的 JDK 版本 1.8 來說，String 內部實際存儲結構爲 char 數組，源碼如下：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    // 用於存儲字符串的值
    private final char value[];
    // 緩存字符串的 hash code
    private int hash; // Default to 0
    // ......其他內容
}

String 源碼中包含下面幾個重要的方法。

1. 多構造方法

String 字符串有以下 4 個重要的構造方法：

// String 爲參數的構造方法
public String(String original) {
    this.value = original.value;
    this.hash = original.hash;
}
// char[] 爲參數構造方法
public String(char value[]) {
    this.value = Arrays.copyOf(value, value.length);
}
// StringBuffer 爲參數的構造方法
public String(StringBuffer buffer) {
    synchronized(buffer) {
        this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
    }
}
// StringBuilder 爲參數的構造方法
public String(StringBuilder builder) {
    this.value = Arrays.copyOf(builder.getValue(), builder.length());
}

其中，比較容易被我們忽略的是以 StringBuffer 和 StringBuilder 爲參數的構造函數，因爲這三種數據類型，我們通常都是單獨使用的，所以這個小細節我們需要特別留意一下。

2. equals() 比較兩個字符串是否相等

源碼如下：

public boolean equals(Object anObject) {
    // 對象引用相同直接返回 true
    if (this == anObject) {
        return true;
    }
    // 判斷需要對比的值是否爲 String 類型，如果不是則直接返回 false
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            // 把兩個字符串都轉換爲 char 數組對比
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            // 循環比對兩個字符串的每一個字符
            while (n-- != 0) {
                // 如果其中有一個字符不相等就 true false，否則繼續對比
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

String 類型重寫了 Object 中的 equals() 方法，equals() 方法需要傳遞一個 Object 類型的參數值，在比較時會先通過 instanceof 判斷是否爲 String 類型，如果不是則會直接返回 false，instanceof 的使用如下：

Object oString = "123";
Object oInt = 123;
System.out.println(oString instanceof String); // 返回 true
System.out.println(oInt instanceof String); // 返回 false

當判斷參數爲 String 類型之後，會循環對比兩個字符串中的每一個字符，當所有字符都相等時返回 true，否則則返回 false。

還有一個和 equals() 比較類似的方法 equalsIgnoreCase()，它是用於忽略字符串的大小寫之後進行字符串對比。

3. compareTo() 比較兩個字符串

compareTo() 方法用於比較兩個字符串，返回的結果爲 int 類型的值，源碼如下：

public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    // 獲取到兩個字符串長度最短的那個 int 值
    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;
}

從源碼中可以看出，compareTo() 方法會循環對比所有的字符，當兩個字符串中有任意一個字符不相同時，則 return char1-char2。比如，兩個字符串分別存儲的是 1 和 2，返回的值是 -1；如果存儲的是 1 和 1，則返回的值是 0 ，如果存儲的是 2 和 1，則返回的值是 1。

還有一個和 compareTo() 比較類似的方法 compareToIgnoreCase()，用於忽略大小寫後比較兩個字符串。

可以看出 compareTo() 方法和 equals() 方法都是用於比較兩個字符串的，但它們有兩點不同：

equals() 可以接收一個 Object 類型的參數，而 compareTo() 只能接收一個 String 類型的參數；
equals() 返回值爲 Boolean，而 compareTo() 的返回值則爲 int。

它們都可以用於兩個字符串的比較，當 equals() 方法返回 true 時，或者是 compareTo() 方法返回 0 時，則表示兩個字符串完全相同。

4. 其他重要方法

indexOf()：查詢字符串首次出現的下標位置
lastIndexOf()：查詢字符串最後出現的下標位置
contains()：查詢字符串中是否包含另一個字符串
toLowerCase()：把字符串全部轉換成小寫
toUpperCase()：把字符串全部轉換成大寫
length()：查詢字符串的長度
trim()：去掉字符串首尾空格
replace()：替換字符串中的某些字符
split()：把字符串分割並返回字符串數組
join()：把字符串數組轉爲字符串

5.== 和 equals 的區別

== 對於基本數據類型來說，是用於比較 “值”是否相等的；而對於引用類型來說，是用於比較引用地址是否相同的。

查看源碼我們可以知道 Object 中也有 equals() 方法，源碼如下：

public boolean equals(Object obj) {
    return (this == obj);
}

可以看出，Object 中的 equals() 方法其實就是 ==，而 String 重寫了 equals() 方法把它修改成比較兩個字符串的值是否相等。

源碼如下：

public boolean equals(Object anObject) {
    // 對象引用相同直接返回 true
    if (this == anObject) {
        return true;
    }
    // 判斷需要對比的值是否爲 String 類型，如果不是則直接返回 false
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            // 把兩個字符串都轉換爲 char 數組對比
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            // 循環比對兩個字符串的每一個字符
            while (n-- != 0) {
                // 如果其中有一個字符不相等就 true false，否則繼續對比
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

6.final 修飾的好處

從 String 類的源碼我們可以看出 String 是被 final 修飾的不可繼承類，源碼如下：

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

那這樣設計有什麼好處呢？

Java 語言之父 James Gosling 的回答是，他會更傾向於使用 final，因爲它能夠緩存結果，當你在傳參時不需要考慮誰會修改它的值；如果是可變類的話，則有可能需要重新拷貝出來一個新值進行傳參，這樣在性能上就會有一定的損失。

James Gosling 還說迫使 String 類設計成不可變的另一個原因是安全，當你在調用其他方法時，比如調用一些系統級操作指令之前，可能會有一系列校驗，如果是可變類的話，可能在你校驗過後，它的內部的值又被改變了，這樣有可能會引起嚴重的系統崩潰問題，這是迫使 String 類設計成不可變類的一個重要原因。

總結來說，使用 final 修飾的第一個好處是安全；第二個好處是高效，以 JVM 中的字符串常量池來舉例，如下兩個變量：

String s1 = "java";
String s2 = "java";

只有字符串是不可變時，我們才能實現字符串常量池，字符串常量池可以爲我們緩存字符串，提高程序的運行效率，如下圖所示：

試想一下如果 String 是可變的，那當 s1 的值修改之後，s2 的值也跟着改變了，這樣就和我們預期的結果不相符了，因此也就沒有辦法實現字符串常量池的功能了。

7.String 和 StringBuilder、StringBuffer 的區別

因爲 String 類型是不可變的，所以在字符串拼接的時候如果使用 String 的話性能會很低，因此我們就需要使用另一個數據類型 StringBuffer，它提供了 append 和 insert 方法可用於字符串的拼接，它使用 synchronized 來保證線程安全，如下源碼所示：

@Override
public synchronized StringBuffer append(Object obj) {
    toStringCache = null;
    super.append(String.valueOf(obj));
    return this;
}

@Override
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

因爲它使用了 synchronized 來保證線程安全，所以性能不是很高，於是在 JDK 1.5 就有了 StringBuilder，它同樣提供了 append 和 insert 的拼接方法，但它沒有使用 synchronized 來修飾，因此在性能上要優於 StringBuffer，所以在非併發操作的環境下可使用 StringBuilder 來進行字符串拼接。

8.String 和 JVM

String 常見的創建方式有兩種，new String() 的方式和直接賦值的方式，直接賦值的方式會先去字符串常量池中查找是否已經有此值，如果有則把引用地址直接指向此值，否則會先在常量池中創建，然後再把引用指向此值；而 new String() 的方式一定會先在堆上創建一個字符串對象，然後再去常量池中查詢此字符串的值是否已經存在，如果不存在會先在常量池中創建此字符串，然後把引用的值指向此字符串，如下代碼所示：

String s1 = new String("Java");
String s2 = s1.intern();
String s3 = "Java";
System.out.println(s1 == s2); // false
System.out.println(s2 == s3); // true

它們在 JVM 存儲的位置，如下圖所示

小貼士：JDK 1.7 之後把永生代換成的元空間，把字符串常量池從方法區移到了 Java 堆上。

除此之外編譯器還會對 String 字符串做一些優化，例如以下代碼：

String s1 = "Ja" + "va";
String s2 = "Java";
System.out.println(s1 == s2);

雖然 s1 拼接了多個字符串，但對比的結果卻是 true，我們使用反編譯工具，看到的結果如下：

Compiled from "StringExample.java"
public class com.lagou.interview.StringExample {
  public com.lagou.interview.StringExample();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
    LineNumberTable:
      line 3: 0

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String Java
       2: astore_1
       3: ldc           #2                  // String Java
       5: astore_2
       6: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       9: aload_1
      10: aload_2
      11: if_acmpne     18
      14: iconst_1
      15: goto          19
      18: iconst_0
      19: invokevirtual #4                  // Method java/io/PrintStream.println:(Z)V
      22: return
    LineNumberTable:
      line 5: 0
      line 6: 3
      line 7: 6
      line 8: 22
}

從編譯代碼 #2 可以看出，代碼 "Ja"+"va" 被直接編譯成了 "Java" ，因此 s1==s2 的結果纔是 true，這就是編譯器對字符串優化的結果。

Java深入淺出之String

String 是如何實現的？它有哪些重要的方法？

以主流的 JDK 版本 1.8 來說，String 內部實際存儲結構爲 char 數組，源碼如下：

1. 多構造方法

2. equals() 比較兩個字符串是否相等

3. compareTo() 比較兩個字符串

4. 其他重要方法

5.== 和 equals 的區別

6.final 修飾的好處

7.String 和 StringBuilder、StringBuffer 的區別

8.String 和 JVM

Flink分區策略

Flink 什麼情況下才會把 Operator chain 在一起形成算子鏈？

Java深入淺出之HashMap

Java深入淺出之String

Java深入淺出之線程

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結