摘要：有一種學(xué)得快的方法，就是一次不要學(xué)太多。用修飾的字符數(shù)組存儲字符串解答有三點(diǎn)在底層是用一個修飾的字符數(shù)組來存儲字符串的。修飾符保證了這個引用變量是不可變的，修飾符則保證了是類私有的，不能通過對象實(shí)例去訪問和更改數(shù)組里存放的字符。

有一種學(xué)得快的方法，就是一次不要學(xué)太多。

public final class String implements Serializable, Comparable, CharSequence {
    private final char[] value; // 用 private final 修飾的字符數(shù)組存儲字符串
    private int hash;
    private static final long serialVersionUID = -6849794470754667710L;
    
    public String() {
        this.value = "".value; 
    }

    public String(String var1) {
        this.value = var1.value;
        this.hash = var1.hash;
    }

    public String(char[] var1) {
        this.value = Arrays.copyOf(var1, var1.length);
    }
    ......
}

有三點(diǎn)：
1）String 在底層是用一個 private final 修飾的字符數(shù)組 value 來存儲字符串的。final 修飾符保證了 value 這個引用變量是不可變的，private 修飾符則保證了 value 是類私有的，不能通過對象實(shí)例去訪問和更改 value 數(shù)組里存放的字符。

注：有很多地方說 String 不可變是 final 起的作用，其實(shí)不嚴(yán)謹(jǐn)。因?yàn)榧词刮也挥?final 修改 value ，但初始化完成后我能保證以后都不更改 value 這個引用變量和 value[] 數(shù)組里存放的值，它也是從沒變化過的。final 只是保證了 value 這個引用變量是不能更改的，但不能保證 value[] 數(shù)組里存放的字符是不能更改的。如果把 private 改為 public 修飾，String類的對象是可以通過訪問 value 去更改 value[] 數(shù)組里存放的字符的，這時 String 就不再是不可變的了。所以不如說 private 起的作用更大一些。后面我們會通過 代碼1處 去驗(yàn)證。

2）String 類并沒有對外暴露可以修改 value[] 數(shù)組內(nèi)容的方法，并且 String 類內(nèi)部對字符串的操作和改變都是通過新建一個 String 對象去完成的，操作完返回的是新的 String 對象，并沒有改變原來對象的 value[] 數(shù)組。

注：String 類如果對外暴露可以更改 value[] 數(shù)組的方法，如 setter 方法，也是不能保證 String 是不可變的。后面我們會通過 代碼2處 去驗(yàn)證。

3）String 類是用 final 修飾的，保證了 String 類是不能通過子類繼承去破壞或更改它的不可變性的。

注：如果 String 類不是用 final 修飾的，也就是 String 類是可以被子類繼承的，那子類就可以改變父類原有的方法或?qū)傩?。后面我們會通過 代碼3處 去驗(yàn)證。

以上三個條件同時滿足，才讓 String 類成了不可變類，才讓 String 類具有了一旦實(shí)例化就不能改變它的內(nèi)容的屬性。

面試問題：String 類是用什么數(shù)據(jù)結(jié)構(gòu)來存儲字符串的？
由上面 String 的源碼可見，String 類是用數(shù)組的數(shù)據(jù)結(jié)構(gòu)來存儲字符串的。

我們來看看如果把 private 修飾符換成 public，看看會發(fā)生什么？

// 先來模擬一個String類，初始化的時候?qū)?String 轉(zhuǎn)成 value 數(shù)組存儲
public final class WhyStringImutable {
   public final char[] value;  // 修飾符改成了 public 
   
   public WhyStringImutable() {
       this.value = "".toCharArray();
   }
   
   public WhyStringImutable(String str){
       this.value = str.toCharArray(); // 初始化時轉(zhuǎn)為字符數(shù)組
   }
   
   public char[] getValue(){
       return this.value;
   }
}

public class WhyStringImutableTest {
    public static void main(String[] args) {
        WhyStringImutable str = new WhyStringImutable("abcd");
        System.out.println("原str中value數(shù)組的內(nèi)容為：");
        System.out.println(str.getValue()); // 打印str對象中存放的字符數(shù)組
        System.out.println("----------");
        str.value[1] = "e"; // 通過對象實(shí)例訪問value數(shù)組并修改其內(nèi)容
        System.out.println("修改后str中value數(shù)組的內(nèi)容為：");
        System.out.println(str.getValue()); // 打印str對象中存放的字符數(shù)組
   }
}

輸出結(jié)果：

原str中value數(shù)組的內(nèi)容為：
abcd
----------
修改后str中value數(shù)組的內(nèi)容為：
aecd

由此可見，private 修改為 public 后，String 是可以通過對象實(shí)例訪問并修改所保存的value 數(shù)組的，并不能保證 String 的不可變性。

我們?nèi)绻麑ν獗┞犊梢愿?value[] 數(shù)組的方法，如 setter 方法，看看又會發(fā)生什么？

public final class WhyStringImutable {
    private final char[] value;

    public WhyStringImutable() {
        this.value = "".toCharArray();
    }

    public WhyStringImutable(String str){
        this.value = str.toCharArray();
    }
    
    // 對外暴露可以修改 value 數(shù)組的方法
    public void setValue(int i, char ch){
        this.value[i] = ch;
    }
    
    public char[] getValue(){
        return this.value;
    }

}

public class WhyStringImutableTest {
    public static void main(String[] args) {
        WhyStringImutable str = new WhyStringImutable("abcd");
        System.out.println("原str中value數(shù)組的內(nèi)容為：");
        System.out.println(str.getValue()); // 打印str對象中存放的字符數(shù)組
        System.out.println("----------");
        str.setValue(1,"e"); // 通過set方法改變指定位置的value數(shù)組元素
        System.out.println("修改后str中value數(shù)組的內(nèi)容為：");
        System.out.println(str.getValue()); // 打印str對象中存放的字符數(shù)組
   }
}

輸出結(jié)果：

原str中value數(shù)組的內(nèi)容為：
abcd
----------
修改后str中value數(shù)組的內(nèi)容為：
aecd

由此可見，如果對外暴露了可以更改 value[] 數(shù)組內(nèi)容的方法，也是不能保證 String 的不可變性的。

如果 WhyStringImutable 類去掉 final 修飾，其他的保持不變，又會怎樣呢？

public class WhyStringImutable {
    private final char[] value;
    
    public WhyStringImutable() {
        this.value = "".toCharArray();
    }
    
    public WhyStringImutable(String str){
        this.value = str.toCharArray(); // 初始化時轉(zhuǎn)為字符數(shù)組
    }
    
    public char[] getValue(){
        return this.value;
    }
}

寫一個子類繼承自WhyStringImutable 并修改原來父類的屬性，實(shí)現(xiàn)子類自己的邏輯：

public class WhyStringImutableChild extends WhyStringImutable {

    public char[] value; // 修改字符數(shù)組為 public 修飾，不要 final 

    public WhyStringImutableChild(String str){
        this.value = str.toCharArray();
    }

    public WhyStringImutableChild() {
        this.value = "".toCharArray();
    }

    @Override
    public char[] getValue() {
        return this.value;
    }
}

public class WhyStringImutableTest {
    public static void main(String[] args) {
        WhyStringImutableChild str = new WhyStringImutableChild("abcd");
        System.out.println("原str中value數(shù)組的內(nèi)容為：");
        System.out.println(str.getValue());
        System.out.println("----------");
        str.value[1] = "s";
        System.out.println("修改后str中value數(shù)組的內(nèi)容為：");
        System.out.println(str.getValue());
    }
}

運(yùn)行結(jié)果：

原str中value數(shù)組的內(nèi)容為：
abcd
----------
修改后str中value數(shù)組的內(nèi)容為：
ascd

由此可見，如果 String 類不是用 final 修飾的，是可以通過子類繼承來修改它原來的屬性的，所以也是不能保證它的不可變性的。

綜上所分析，String 不可變的原因是 JDK 設(shè)計(jì)者巧妙的設(shè)計(jì)了如上三點(diǎn)，保證了String 類是個不可變類，讓 String 具有了不可變的屬性。考驗(yàn)的是工程師構(gòu)造數(shù)據(jù)類型，封裝數(shù)據(jù)的功力，而不是簡單的用 final 來修飾，背后的設(shè)計(jì)思想值得我們理解和學(xué)習(xí)。

從上面的分析，我們知道，String 確實(shí)是個不可變的類，但我們就真的沒辦法改變 String 對象的值了嗎？不是的，通過反射可以改變 String 對象的值。

但是請謹(jǐn)慎那么做，因?yàn)橐坏┩ㄟ^反射改變對應(yīng)的 String 對象的值，后面再創(chuàng)建相同內(nèi)容的 String 對象時都會是反射改變后的值，這時候在后面的代碼邏輯執(zhí)行時就會出現(xiàn)讓你 “摸不著頭腦” 的現(xiàn)象，具有迷惑性，出了奇葩的問題你也很難排除到原因。后面在 代碼4處 我們會驗(yàn)證這個問題。

先來看看如何通過反射改變 String 對象的內(nèi)容：

public class WhyStringImutableTest {
    public static void main(String[] args) {
        String str = new String("123");
        System.out.println("反射前 str:"+str);
        try {
            Field field = String.class.getDeclaredField("value");
            field.setAccessible(true);
            char[] aa = (char[]) field.get(str);
            aa[1] = "1";
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
        System.out.println("反射后 str："+str);
}

打印結(jié)果：

反射前 str:123
反射后 str：113 // 可見，反射后，str 的值確實(shí)改變了

下面我們來驗(yàn)證因?yàn)橐坏┩ㄟ^反射改變對應(yīng)的 String 對象的值，后面再創(chuàng)建相同內(nèi)容的 String 對象時都會是反射改變后的值的問題：

public class WhyStringImutableTest {
    public static void main(String[] args) {
        String str = new String("123");
        System.out.println("反射前 str:"+str);
        try {
            Field field = String.class.getDeclaredField("value");
            field.setAccessible(true);
            char[] aa = (char[]) field.get(str);
            aa[1] = "1";
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
        System.out.println("反射后 str："+str);
        
        String str2 = new String("123");
        System.out.println("str2:"+str2); // 我們來看 str2 會輸出什么，會輸出 113？
        System.out.println("判斷是否是同一對象："+(str == str2)); // 判斷 str 和 str2 的內(nèi)存地址值是否相等
        System.out.println("判斷內(nèi)容是否相同："+str.equals(str2)); // 判斷 str 和 str2 的內(nèi)容是否相等
}

執(zhí)行結(jié)果如下：

反射前 str:123
反射后 str：113
str2:113 // 竟然不是123？？而是輸出113，說明 str2 也是反射修改后的值。
判斷是否是同一對象：false // 輸出 false，說明在內(nèi)存中確實(shí)創(chuàng)建了兩個不同的對象
判斷內(nèi)容是否相同：true   // 輸出true，說明依然判斷為兩個對象內(nèi)容是相等的

由上面的輸出結(jié)果，我們可知，反射后再新建相同內(nèi)容的字符串對象時會是反射修改后的值，這就造成了很大迷惑性，在實(shí)際開發(fā)中要謹(jǐn)慎這么做。