什麼是字符串常量池？

在理解字符串常量前，我們先熟悉一下如何創建一個字符串，在Java中有兩種方法可以創建一個字符串對象：

• 使用new運算符。例如：

1	String str = new String("Hello");

• 使用字符串常量或者常量表達式。例如：

1 2	String str="Hello"; //(字符串常量) 或者 String str="Hel" + "lo"; //(字符串常量表達式).

這些字符串的創建方式之間有什麼區別呢？在Java中，equals方法被認爲是對象的值進行深層次的比較，而操作符==是進行的淺層次的比較。equals方法比較兩個對象的內容而不是引用。==兩側是引用類型（例如對象）時，如果引用是相同的-即指向同一個對象-則執行結果爲真。如果是值類型（例如原生類型），如果值相同，則執行結果爲真。equals方法在兩個對象具有相同內容時返回真-但是，java.lang.Object類中的equals方法返回真-如果類沒有覆蓋默認的equals方法，如果兩個引用指向同一個對象。

讓我們通過下面的例子來看看這兩種字符串的創建方式之間有什麼區別吧。

public class DemoStringCreation {

    public static void main(String args[]) {

        String str1 = "Hello";

        String str2 = "Hello";

        System.out.println("str1 and str2 are created by using string literal.");

        System.out.println("    str1 == str2 is " + (str1 == str2));

        System.out.println("    str1.equals(str2) is " + str1.equals(str2)); 

        String str3 = new String("Hello");

        String str4 = new String("Hello");

        System.out.println("str3 and str4 are created by using new operator.");

        System.out.println("    str3 == str4 is " + (str3 == str4));

        System.out.println("    str3.equals(str4) is " + str3.equals(str4)); 

        String str5 = "Hel" + "lo";

        String str6 = "He" + "llo";

        System.out.println("str5 and str6 are created by using string constant expression.");

        System.out.println("    str5 == str6 is " + (str5 == str6));

        System.out.println("    str5.equals(str6) is " + str5.equals(str6)); 

        String s = "lo";

        String str7 = "Hel" + s;

        String str8 = "He" + "llo";

        System.out.println("str7 is computed at runtime.");

        System.out.println("str8 is created by using string constant expression.");

        System.out.println("    str7 == str8 is " + (str7 == str8));

        System.out.println("    str7.equals(str8) is " + str7.equals(str8)); 

    }

}
輸出結果爲：


str1 and str2 are created by using string literal.

    str1 == str2 is true

    str1.equals(str2) is true

str3 and str4 are created by using new operator.

    str3 == str4 is false

    str3.equals(str4) is true

str5 and str6 are created by using string constant expression.

    str5 == str6 is true

    str5.equals(str6) is true

str7 is computed at runtime.

str8 is created by using string constant expression.

    str7 == str8 is false

    str7.equals(str8) is true

使用相同的字符序列而不是使用new關鍵字創建的兩個字符串會創建指向Java字符串常量池中的同一個字符串的指針。字符串常量池是Java節約資源的一種方式。

字符串常量池

字符串的分配，和其他的對象分配一樣，耗費高昂的時間與空間代價。JVM爲了提高性能和減少內存開銷，在實例化字符串常量的時候進行了一些優化。爲了減少在JVM中創建的字符串的數量，字符串類維護了一個字符串池，每當代碼創建字符串常量時，JVM會首先檢查字符串常量池。如果字符串已經存在池中，就返回池中的實例引用。如果字符串不在池中，就會實例化一個字符串並放到池中。Java能夠進行這樣的優化是因爲字符串是不可變的，可以不用擔心數據衝突進行共享。例如：

public class Program

{

    public static void main(String[] args)

    {

       String str1 = "Hello"; 

       String str2 = "Hello";

       System.out.print(str1 == str2);

    }

}

其結果是：

true

不幸的是，當使用：

String a=new String("Hello");

一個字符串對象在字符串常量池外創建，即使池裏存在相同的字符串。考慮到這些，要避免new一個字符串除非你明確的知道需要這麼做！例如：

public class Program

{

    public static void main(String[] args)

    {

       String str1 = "Hello"; 

       String str2 = new String("Hello");

       System.out.print(str1 == str2 + " ");

       System.out.print(str1.equals(str2));

    }

}

結果是：

false true

JVM中有一個常量池，任何字符串至多維護一個對象。字符串常量總是指向字符串池中的一個對象。通過new操作符創建的字符串對象不指向字符串池中的任何對象，但是可以通過使用字符串的intern()方法來指向其中的某一個。java.lang.String.intern()返回一個保留池字符串，就是一個在全局字符串池中有了一個入口。如果以前沒有在全局字符串池中，那麼它就會被添加到裏面。例如：

public class Program

{

    public static void main(String[] args)

    {

        // Create three strings in three different ways.

        String s1 = "Hello";

        String s2 = new StringBuffer("He").append("llo").toString();

        String s3 = s2.intern();

 

        // Determine which strings are equivalent using the ==

        // operator

        System.out.println("s1 == s2? " + (s1 == s2));

        System.out.println("s1 == s3? " + (s1 == s3));

    }

}

輸出是：

s1 == s2? false

s1 == s3? true

爲了優化空間，運行時實例創建的全局字符串常量池中有一個表，總是爲池中每個唯一的字符串對象維護一個引用。這就意味着它們一直引用着字符串常量池中的對象，所以，在常量池中的這些字符串不會被垃圾收集器回收。

Java語言規範第三版中的字符串常量

每一個字符串常量都是指向一個字符串類實例的引用。字符串對象有一個固定值。字符串常量，或者一般的說，常量表達式中的字符串都被使用方法 String.intern進行保留來共享唯一的實例。

package testPackage;

class Test {

        public static void main(String[] args) {

                String hello = "Hello", lo = "lo";

                System.out.print((hello == "Hello") + " ");

                System.out.print((Other.hello == hello) + " ");

                System.out.print((other.Other.hello == hello) + " ");

                System.out.print((hello == ("Hel"+"lo")) + " ");

                System.out.print((hello == ("Hel"+lo)) + " ");

                System.out.println(hello == ("Hel"+lo).intern());

        }

}

class Other { static String hello = "Hello"; }

編譯單元：

1 2	package other; public class Other { static String hello = "Hello"; }

產生輸出：

1	true true true true false true

這個例子說明了六點：

• 同一個包下同一個類中的字符串常量的引用指向同一個字符串對象；
• 同一個包下不同的類中的字符串常量的引用指向同一個字符串對象；
• 不同的包下不同的類中的字符串常量的引用仍然指向同一個字符串對象；
• 由常量表達式計算出的字符串在編譯時進行計算,然後被當作常量；
• 在運行時通過連接計算出的字符串是新創建的，因此是不同的；
• 通過計算生成的字符串顯示調用intern方法後產生的結果與原來存在的同樣內容的字符串常量是一樣的。

原文鏈接： xyzws 翻譯： ImportNew.com - lumeng689
譯文鏈接： http://www.importnew.com/10756.html