真的懂Java的String嗎？

1.String的特性

1.1不變性

咱們經常聽人說，HashMap 的 key 建議使用不可變類，好比說 String 這種不可變類。這裏說不可變指的是類值一旦被初始化，就不能再被改變了，若是被修改，將會是新的類，咱們寫個demo 來演示一下。

public class test {
    public static void main(String[] args){
        String str="hello";
        str=str+"world";
    }
}
複製代碼

從代碼上來看，s 的值好像被修改了，但從 debug 的日誌來看，實際上是 s 的內存地址已經被修了，也就說 s =「world」 這個看似簡單的賦值，其實已經把 s 的引用指向了新的 String，debug 截圖顯示內存地址已經被修改，兩張截圖以下，咱們能夠看到標紅的地址值已經修改了。

​​

用示意圖來表示堆內存，即見下圖。

​

咱們能夠看下str的地址已經改了，說了生成了兩個字符串，String類的官方註釋爲Strings are constant; their values cannot be changed after they are created. 簡單翻譯下爲字符串是常量；它們的值在建立後不能更改。

下面爲String的相關代碼，以下代碼，咱們能夠看到：

1. String 被 final 修飾，說明 String 類毫不可能被繼承了，也就是說任何對 String 的操做方法，都不會被繼承覆寫，便可保證雙親委派機制，保證基類的安全性。
2. String 中保存數據的是一個 char 的數組 value。咱們發現 value 也是被 final 修飾的，也就是說 value 一旦被賦值，內存地址是絕對沒法修改的，並且 value 的權限是 private 的，外部絕對訪問不到，String沒有開放出能夠對 value 進行賦值的方法，因此說 value 一旦產生，內存地址就根本沒法被修改。

/** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;
複製代碼

1.2相等判斷

相等判斷邏輯寫的很清楚明瞭，若是有人問如何判斷二者是否相等時，咱們能夠從二者的底層結構出發，這樣能夠迅速想到一種貼合實際的思路和方法，就像 String 底層的數據結構是 char 的數組同樣，判斷相等時，就挨個比較 char 數組中的字符是否相等便可。

（這裏先挖個坑，攜程問過相似題目）

public boolean equals(Object anObject) {
       //若是地址相等，則直接返回true       
       if (this == anObject) {
            return true;
        }
        //若是爲String字符串，則進行下面的邏輯判斷
        if (anObject instanceof String) {
            //將對象轉化爲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循環挨個比較每一個char
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
複製代碼

相等邏輯的流程圖以下，咱們能夠看到整個流程仍是很清楚的。

​

1.3替換操做

替換在平時工做中也常用，主要有 replace 替換全部字符、replaceAll 批量替換字符串、replaceFirst這三種場景。
下面寫了一個 demo 演示一下三種場景：

public static void main(String[] args) {
        String str = "hello word !!";
        System.out.println("替換以前 :" + str);
        str = str.replace('l', 'd');
        System.out.println("替換全部字符 :" + str);
        str = str.replaceAll("d", "l");
        System.out.println("替換所有 :" + str);
        str = str.replaceFirst("l", "");
        System.out.println("替換第一個 l :" + str);
    }
複製代碼

輸出的結果是：
​

這邊要注意一點是replace和replaceAll的區別，不是替換和替換全部的區別哦。

而是replaceAll支持正則表達式，所以會對參數進行解析（兩個參數均是），如replaceAll("d", "")，而replace則不會，replace("d","")就是替換"d"的字符串，而不會解析爲正則。

1.4 intern方法

String.intern() 是一個 Native 方法，便是c和c++與底層交互的代碼，它的做用（在

JDK1.6和1.7操做不一樣

）是：

若是運行時常量池中已經包含一個等於此 String 對象內容的字符串，則直接返回常量池中該字符串的引用；

若是沒有， 那麼

在jdk1.6中，將此String對象添加到常量池中，而後返回這個String對象的引用（此時引用的串在常量池）。

在jdk1.7中，放入一個引用，指向堆中的String對象的地址，返回這個引用地址（此時引用的串在堆）。

/**
     * Returns a canonical representation for the string object.
     * <p>
     * A pool of strings, initially empty, is maintained privately by the
     * class {@code String}.
     * <p>
     * When the intern method is invoked, if the pool already contains a
     * string equal to this {@code String} object as determined by
     * the {@link #equals(Object)} method, then the string from the pool is
     * returned. Otherwise, this {@code String} object is added to the
     * pool and a reference to this {@code String} object is returned.
     * <p>
     * It follows that for any two strings {@code s} and {@code t},
     * {@code s.intern() == t.intern()} is {@code true}
     * if and only if {@code s.equals(t)} is {@code true}.
     * <p>
     * All literal strings and string-valued constant expressions are
     * interned. String literals are defined in section 3.10.5 of the
     * <cite>The Java&trade; Language Specification</cite>.
     *
     * @return  a string that has the same contents as this string, but is
     *          guaranteed to be from a pool of unique strings.
     */    
public native String intern();
複製代碼

若是看上面看不懂，咱們來看下一下具體的例子，並來分析下。

public static void main(String[] args) {
        String s1 = new String("學習Java的小姐姐");
        s1.intern();
        String s2 = "學習Java的小姐姐";
        System.out.println(s1 == s2);

        String s3 = new String("學習Java的小姐姐") + new String("test");
        s3.intern();
        String s4 = "學習Java的小姐姐test";
        System.out.println(s3 == s4);

    }
複製代碼

咱們來看下結果，實際的打印信息以下。

​

爲何顯示這樣的結果，咱們來看下。因此在 jdk7 的版本中，字符串常量池已經從方法區移到正常的堆 區域了。

• 第一個false： 第一句代碼String s1 = new String("學習Java的小姐姐");生成了2個對象。常量池中的「學習Java的小姐姐」 和堆中的字符串對象。s1.intern(); 這一句是 s1 對象去常量池中尋找後，發現 「學習Java的小姐姐」 已經在常量池裏了。接下來String s2 = "學習Java的小姐姐"; 這句代碼是生成一個 s2的引用指向常量池中的「學習Java的小姐姐」對象。 結果就是 s 和 s2 的引用地址明顯不一樣，因此爲打印結果是false。
• 第二個true:先看 s3和s4字符串。String s3 = new String("學習Java的小姐姐") + new String("test");，這句代碼中如今生成了3個對象，是字符串常量池中的「學習Java的小姐姐」 ,"test"和堆 中的 s3引用指向的對象。此時s3引用對象內容是」學習Java的小姐姐test」，但此時常量池中是沒有 「學習Java的小姐姐test」對象的，接下來s3.intern();這一句代碼，是將 s3中的「學習Java的小姐姐test」字符串放入 String 常量池中，由於此時常量池中不存在「學習Java的小姐姐test」字符串，常量池不須要再存儲一份對象了，能夠直接存儲堆中的引用。這份引用指向 s3 引用的對象。 也就是說引用地址是相同的。最後String s4 = "學習Java的小姐姐test"; 這句代碼中」學習Java的小姐姐test」是顯示聲明的，所以會直接去常量池中建立，建立的時候發現已經有這個對象了，此時也就是指向 s3 引用對象的一個引用。因此 s4 引用就指向和 s3 同樣了。所以最後的比較 s3 == s4 是 true。

​

咱們再看下，若是把上面的兩行代碼調整下位置，打印結果是否是不一樣。

public static void main(String[] args) {
        String s1 = new String("學習Java的小姐姐");
        String s2 = "學習Java的小姐姐";
        s1.intern();
        System.out.println(s1 == s2);

        String s3 = new String("學習Java的小姐姐") + new String("test");
        String s4 = "學習Java的小姐姐test";
        s3.intern();
        System.out.println(s3 == s4);

    }
複製代碼

​

第一個false: s1 和 s2 代碼中，s1.intern();，這一句日後放也不會有什麼影響了，由於對象池中在執行第一句代碼String s = new String("學習Java的小姐姐");的時候已經生成「學習Java的小姐姐」對象了。下邊的s2聲明都是直接從常量池中取地址引用的。 s 和 s2 的引用地址是不會相等的。

第二個false：與上面惟一的區別在於 s3.intern(); 的順序是放在String s4 = "學習Java的小姐姐test";後了。這樣，首先執行String s4 = "學習Java的小姐姐test";聲明 s4 的時候常量池中是不存在「學習Java的小姐姐test」對象的，執行完畢後，「學習Java的小姐姐test「對象是 s4 聲明產生的新對象。而後再執行s3.intern();時，常量池中「學習Java的小姐姐test」對象已經存在了，所以 s3 和 s4 的引用是不一樣的。

1. String、StringBuilder和StringBuffer

2.1 繼承結構

​
-

2.2 主要區別

1）String是不可變字符序列，StringBuilder和StringBuffer是可變字符序列。
2）執行速度StringBuilder > StringBuffer > String。
3）StringBuilder是非線程安全的，StringBuffer是線程安全的。

參考： 《2020最新Java基礎精講視頻教程和學習路線！》
連接：https://juejin.cn/post/694526...