2. 程式人生 > >String類設計成final的原因

String類設計成final的原因

阿新 • • 發佈：2019-01-24

我進行了重新排版，並且更換了其中的一個例子，讓我們更好理解。

String很多實用的特性，比如說“不可變性”，是工程師精心設計的藝術品！藝術品易碎！用final就是拒絕繼承，防止世界被熊孩子破壞，維護世界和平！

1. 什麼是不可變？

String不可變很簡單，如下圖，給一個已有字串“abcd”第二次賦值成“abcedl”，不是在原記憶體地址上修改資料，而是重新指向一個新物件，新地址。


2. String為什麼不可變？

翻開JDK原始碼，java.lang.String類起手前三行，是這樣寫的：

[java] view plain copy print?
  1. publicfinalclass String 
    implements java.io.Serializable, Comparable<String>, CharSequence {  
  2.     /** String本質是個char陣列. 而且用final關鍵字修飾.*/
  3.     privatefinalchar value[];  
  4.     …  
  5.     …  
  6. }  
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    /** String本質是個char陣列. 而且用final關鍵字修飾.*/
    private final char value[];
    ...
    ...
}

首先String類是用final關鍵字修飾，這說明String不可繼承。再看下面，String類的主力成員欄位value是個char[ ]陣列，而且是用final修飾的。final修飾的欄位建立以後就不可改變。有的人以為故事就這樣完了，其實沒有。因為雖然value是不可變，也只是value這個引用地址不可變。擋不住Array陣列是可變的事實。Array的資料結構看下圖

也就是說Array變數只是stack上的一個引用，陣列的本體結構在heap堆。String類裡的value用final修飾，只是說stack裡的這個叫value的引用地址不可變。沒有說堆裡array本身資料不可變。看下面這個例子，

[java] view plain copy print?
  1. finalint[] value={1,2,3}  
  2. int[] another={4,5,6};  
  3. value=another;    //編譯器報錯，final不可變
final int[] value={1,2,3}
int[] another={4,5,6};
value=another;    //編譯器報錯，final不可變

value用final修飾，編譯器不允許我把value指向堆區另一個地址。但如果我直接對陣列元素動手，分分鐘搞定。

[java] view plain copy print?
  1. finalint[] value={1,2,3};  
  2. value[2]=100;  //這時候數組裡已經是{1,2,100}
final int[] value={1,2,3};
value[2]=100;  //這時候數組裡已經是{1,2,100}

或者更粗暴的反射直接改，也是可以的。

[java] view plain copy print?
  1. finalint[] array={1,2,3};  
  2. Array.set(array,2,100); //陣列也被改成{1,2,100}
final int[] array={1,2,3};
Array.set(array,2,100); //陣列也被改成{1,2,100}

所以String是不可變，關鍵是因為SUN公司的工程師，在後面所有String的方法裡很小心的沒有去動Array裡的元素，沒有暴露內部成員欄位。

private final char value[]這一句裡，private的私有訪問許可權的作用都比final大。而且設計師還很小心地把整個String設成final禁止繼承，避免被其他人繼承後破壞。所以String是不可變的關鍵都在底層的實現，而不是一個final。考驗的是工程師構造資料型別，封裝資料的功力。


3. 不可變有什麼好處？

這個最簡單的原因，就是為了安全。

示例1

[java] view plain copy print?
  1. package _12_01字串;  
  2. publicclass 為什麼String要設計成不可變類你 {  
  3.     publicstaticvoid main(String[] args) {  
  4.         String a, b, c;  
  5.         a = ”test”;  
  6.         b = a;  
  7.         c = b;  
  8.         String processA = processA(a);  
  9.         String processB = processB(b);  
  10.         String processC = processC(c);  
  11.         System.out.println(processA);  
  12.         System.out.println(processB);  
  13.         System.out.println(processC);  
  14.     }  
  15.     static String processA(String str){  
  16.         return str + “A”;  
  17.     }  
  18.     static String processB(String str){  
  19.         return str + “B”;  
  20.     }  
  21.     static String processC(String str){  
  22.         return str + “C”;  
  23.     }  
  24. }  
  25. //OUTPUT
  26. // testA
  27. //testB
  28. //testC
package _12_01字串;

public class 為什麼String要設計成不可變類你 {

    public static void main(String[] args) {

        String a, b, c;
        a = "test";
        b = a;
        c = b;
        String processA = processA(a);
        String processB = processB(b);
        String processC = processC(c);
        System.out.println(processA);
        System.out.println(processB);
        System.out.println(processC);
    }

    static String processA(String str){
        return str + "A";
    }

    static String processB(String str){
        return str + "B";
    }

    static String processC(String str){
        return str + "C";
    }

}
//OUTPUT
// testA
//testB
//testC

當String支援非可變性的時候，它們的值很好確定，不管呼叫哪個方法，都互不影響。

如果String是可變的，就可能如下例，我們使用StringBuffer來模擬String是可變的

[java] view plain copy print?
  1. package _12_01字串;  
  2. publicclass 為什麼String要設計成不可變類2 {  
  3.     publicstaticvoid main(String[] args) {  
  4.         StringBuffer a, b, c;  
  5.         a = new StringBuffer(“test”);  
  6.         b = a;  
  7.         c = b;  
  8.         String processA = processA(a);  
  9.         String processB = processB(b);  
  10.         String processC = processC(c);  
  11.         System.out.println(processA);  
  12.         System.out.println(processB);  
  13.         System.out.println(processC);  
  14.     }  
  15.     static String processA(StringBuffer str){  
  16.         return str.append(“A”).toString();  
  17.     }  
  18.     static String processB(StringBuffer str){  
  19.         return str.append(“B”).toString();  
  20.     }  
  21.     static String processC(StringBuffer str){  
  22.         return str.append(“C”).toString();  
  23.     }  
  24. }  
  25. //OUTPUT
  26. // testA
  27. //testAB
  28. //testABC
package _12_01字串;

public class 為什麼String要設計成不可變類2 {

    public static void main(String[] args) {

        StringBuffer a, b, c;
        a = new StringBuffer("test");
        b = a;
        c = b;
        String processA = processA(a);
        String processB = processB(b);
        String processC = processC(c);
        System.out.println(processA);
        System.out.println(processB);
        System.out.println(processC);
    }

    static String processA(StringBuffer str){
        return str.append("A").toString();
    }

    static String processB(StringBuffer str){
        return str.append("B").toString();
    }

    static String processC(StringBuffer str){
        return str.append("C").toString();
    }

}
//OUTPUT
// testA
//testAB
//testABC

能看出b=a,c=b;程式設計師的本意是希望變數是不變的。所以String不可變的安全性就體現在這裡。實際上StringBuffer的作用就是起到了String的可變配套類角色。

示例2

再看下面這個HashSet用StringBuilder做元素的場景，問題就更嚴重了，而且更隱蔽。

[java] view plain copy print?
  1. class Test{  
  2.     publicstaticvoid main(String[] args){  
  3.         HashSet<StringBuilder> hs=new HashSet<StringBuilder>();  
  4.         StringBuilder sb1=new StringBuilder(“aaa”);  
  5.         StringBuilder sb2=new StringBuilder(“aaabbb”);  
  6.         hs.add(sb1);  
  7.         hs.add(sb2);    //這時候HashSet裡是{“aaa”,”aaabbb”}
  8.         StringBuilder sb3=sb1;  
  9.         sb3.append(”bbb”);  //這時候HashSet裡是{“aaabbb”,”aaabbb”}
  10.         System.out.println(hs);  
  11.     }  
  12. }  
  13. //Output:
  14. //[aaabbb, aaabbb]
class Test{
    public static void main(String[] args){
        HashSet<StringBuilder> hs=new HashSet<StringBuilder>();
        StringBuilder sb1=new StringBuilder("aaa");
        StringBuilder sb2=new StringBuilder("aaabbb");
        hs.add(sb1);
        hs.add(sb2);    //這時候HashSet裡是{"aaa","aaabbb"}

        StringBuilder sb3=sb1;
        sb3.append("bbb");  //這時候HashSet裡是{"aaabbb","aaabbb"}
        System.out.println(hs);
    }
}
//Output:
//[aaabbb, aaabbb]
StringBuilder型變數sb1和sb2分別指向了堆內的字面量“aaa”和“aaabbb”。把他們都插入一個HashSet。到這一步沒問題。但如果後面我把變數sb3也指向sb1的地址，再改變sb3的值，因為StringBuilder沒有不可變性的保護，sb3直接在原先“aaa”的地址上改。導致sb1的值也變了。這時候，HashSet上就出現了兩個相等的鍵值“aaabbb”。破壞了HashSet鍵值的唯一性。所以千萬不要用可變型別做HashMap和HashSet鍵值。

不可變性支援執行緒安全

還有一個大家都知道，就是在併發場景下，多個執行緒同時讀一個資源，是不會引發竟態條件的。只有對資源做寫操作才有危險。不可變物件不能被寫，所以執行緒安全。

不可變性支援字串常量池

最後別忘了String另外一個字串常量池的屬性。像下面這樣字串one和two都用字面量“something”賦值。它們其實都指向同一個記憶體地址。

[java] view plain copy print?
  1. String one = “someString”;  
  2. String two = ”someString”;  
String one = "someString";
String two = "someString";


這樣在大量使用字串的情況下，可以節省記憶體空間，提高效率。但之所以能實現這個特性，String的不可變性是最基本的一個必要條件。要是記憶體裡字串內容能改來改去，這麼做就完全沒有意義了。






相關推薦

String類設計成final的原因

我進行了重新排版，並且更換了其中的一個例子，讓我們更好理解。 String很多實用的特性，比如說“不可變性”，是工程師精心設計的藝術品！藝術品易碎！用final就是拒絕繼承，防止世界被熊孩子破壞，維護世界和平！ 1. 什麼是不可變？ String不可變很簡單，如下圖，給一個已有字串“abcd”第二次賦

在java中String類為什麽要設計成final？

tro cli lai 這一 引用 沒有 num 重新 static 大神鏈接：在java中String類為什麽要設計成final？ - 程序員 - 知乎 我進行了重新排版，並且更換了其中的一個例子，讓我們更好理解。 String很多實用的特性，比如說“不可變性”，是工

在Java中String類為什麽要設計成final？String真的不可變嗎?其他基本類型的包裝類也是不可變的嗎？

數據 pri 創建 long tde 繼承 set 字符串常量 通過 最近突然被問到String為什麽被設計為不可變，當時有點懵，這個問題一直像bug一樣存在，竟然沒有發現，沒有思考到，在此總結一下。 1.String的不可變String類被final修飾，是不可繼承和修改

在Java中String類為什麼要設計成final？String真的不可變嗎?其他基本型別的包裝類也是不可變的嗎？

最近突然被問到String為什麼被設計為不可變，當時有點懵，這個問題一直像bug一樣存在，竟然沒有發現，沒有思考到，在此總結一下。 1.String的不可變 String類被final修飾，是不可繼承和修改的。當一個String變數被第二次賦值時，不是在原有記憶體地址上修改資料，而是在記憶體中重

【小家java】String類為什麼要設計成final？不可變有什麼優點？

相關閱讀 原始碼解釋： 先貼一下String類的申明程式碼： public final class String implements java.io.Serializable, Comparable<String>, CharSeque

String為什麼被設計成final以及字串池的學習

為什麼String被設計成final不可變的，我認為主要是2方面的原因，第一點是為了效能，第二點是為了安全 一、效能 先看一個字串緩衝池的例子 String s1 = "ab"; String s3 = "ab"; System.

String被設計成不可變和不能被繼承的原因

String是所有語言中最常用的一個類。我們知道在Java中，String是不可變的、final的。Java在執行時也儲存了一個字串池(String pool)，這使得String成為了一個特別的類。 主要是為了 “ 效率 ” 和 “ 安全性 ” 的緣故。若 String 

String類為什麼是final的

一、理解final 望文生義，final意為“最終的，最後的”，我理解為“不能被改變的”，它可以修飾類、變數和方法。 所以我是否可以理解為被它所修飾的類、變數和方法都不能被改變呢？答案是”是“，因為有以下約束條件的存在： 1、final修飾類 被final修飾的類不能

String類為什麼是final的？

在回答這個問題之前，我覺得有必要搞清楚final到底是個什麼？ 一、理解final 望文生義，final意為“最終的，最後的”，我理解為“不能被改變的”，它可以修飾類、變數和方法。 所以我是否可以理解為被它所修飾的類、變數和方法都不能被改變呢？答案是”是“，因為有以下約

為什麼String要設計成不可變的

1. 字串常量池的需要 字串常量池(String pool, String intern pool, String保留池) 是Java堆記憶體中一個特殊的儲存區域, 當建立一個String物件時,假如此字串值已經存在於常量池中,則不會建立一個新的物件,而是引用已經存在的物件

追根溯源---java.lang.String類為什麼是final的？

java.lang.String類為什麼設計成 final 的？ 首先，先得清楚 final 這個關鍵字。 final的出現就是為了為了不想改變，而不想改變的理由有兩點：設計或者效率。final 修飾的類是不被能繼承的，所以 final 修飾的類是不能被篡改

從字串到常量池，一文看懂String類設計

# 從一道面試題開始 看到這個標題，你肯定以為我又要講這道面試題了 ```java // 這行程式碼建立了幾個物件？ String s3 = new String("1"); ``` 是的，沒錯，我確實要從這裡開始 ![image-20200615221408500](https://imgconv

java裏String類為何被設計為final

使用 hashtable 方向 memory 思維 per 垃圾收集器 其他 tro 　　前些天面試遇到一個非常難的關於String的問題，“String為何被設計為不可變的”？類似的問題也有“String為何被設計為final？”個人認為還是前面一種問法更準確，設計成fi

String為什麽要設置成Final類型

ide cte uid 只有一個 his void rod tor eat ---今天面試碰到個這樣的問題：String在設計的時候為什麽要設計成final的 當時回答的是String功能已經很豐富了，不需要對其進行擴展，所有巴拉巴拉。 現在來正確看看為什麽定義成fina

String 設計成不可變類的好處? OR 為什麼要將String設計成不可變化的?

為什麼String在 java 中是不可變的? 這是一個受歡迎的面試問題。 字串是任何程式語言中使用最多的類之一。 我們知道 String 在 java 和 java 執行時是不可變(immutable

將一個字符串（string類型）轉換成一個int類型

string_to_inint CommString::str_to_int(const std::string &str){ int ivalue = 0; sscanf(str.c_str(), "%d", &ivalue); return ivalue;}本文出自 “簡單可

JavaSE8基礎 String String.valueOf 將int類型變量轉換成同面值大小的String類型

highlight num api pack jdk cnblogs alt urn windows7 os ：windows7 x64 jdk：jdk-8u131-windows-x64 ide：Eclipse Oxygen Release (4.7.

JavaSE8基礎 Integer構造方法 將符合標準的String類型轉成int類型

light 方法 win 異常 javase png integer 基礎 pre os ：windows7 x64 jdk：jdk-8u131-windows-x64 ide：Eclipse Oxygen Release (4.7.0)

string類------新標準c++程序設計

繼續 們的 0x7a 相同 求字符串長度 mut 並不會 部分 返回對象 定義： 　　string類是STL中basic_string模板實例化得到的模板類。其定義如下： typedef basic_string<char>string; 構造函數：　 　　

java中的String類 字符串拆分成字符串數組 判定郵箱地址 字符串比較 看結果？

如何 字符串 string style print 拆分 ret bool char 看結果1？ package com.swift; class ArrayString { public static void main(String[] args) {