Java String常量池

leejan97 發(fā)布于2019-08-19 11:08 / 947人閱讀

摘要：前者在中開辟一個(gè)常量，并返回相應(yīng)的引用，而后者是在中開辟一個(gè)常量，再返回相應(yīng)的對象。方法方法，可以在期間將常量加入到常量池。方法返回這個(gè)新創(chuàng)建的常量的引用。

1. String實(shí)例的初始化

String類型的初始化在Java中分為兩類：

一類是通過雙引號(hào)包裹一個(gè)字符來初始化；

另一類是通過關(guān)鍵字new 像一個(gè)普通的對象那樣初始化一個(gè)String實(shí)例。

前者在constant pool中開辟一個(gè)常量，并返回相應(yīng)的引用，而后者是在heap中開辟一個(gè)常量，再返回相應(yīng)的對象。所以，兩者的reference肯定是不同的：

public static void main(String... args) {
    String s1 = "abcd";
    String s2 = new String("abcd");
    System.out.println(s1 == s2);   // false
}

而constant pool中的常量是可以被共享用于節(jié)省內(nèi)存開銷和創(chuàng)建時(shí)間的開銷（這也是引入constant pool的原因）。例如：

public static void main(String... args) {
    String s1 = "abcd";
    String s2 = "abcd";
    System.out.println(s1 == s2);   // true
}

結(jié)合這兩者，其實(shí)還可以回答另外一個(gè)常見的面試題目：

public static void main(String... args) {
    String s = new String("abcd");
}

這句話創(chuàng)建了幾個(gè)對象？

首先毫無疑問，"abcd"本身是一個(gè)對象，被放于常量池。而由于這里使用了new關(guān)鍵字，所以s得到的對象必然是被創(chuàng)建在heap里的。所以，這里其實(shí)一共創(chuàng)建了2個(gè)對象。

但tricky的部分是，如果在這個(gè)函數(shù)被調(diào)用前的別的地方，已經(jīng)有了"abcd"這個(gè)字符串，那么它就事先在constant pool中被創(chuàng)建了出來。此時(shí)，這里就只會(huì)創(chuàng)建一個(gè)對象，即創(chuàng)建在heap的new String("abcd")對象。

但String的內(nèi)存分配，遠(yuǎn)遠(yuǎn)沒有這么簡單。對于String的拼接，需要做更深入的理解和思考。

2. String的拼接

下面看一個(gè)問題：

public static void main(String... args) {
    String s1 = "hell" + "o";
    String s2 = "h" + "ello";
    System.out.println(s1 == s2);   // true
    System.out.println(s1 == "hello");  // true
    System.out.println(s2 == "hello");  // true
    System.out.println("hello" == "hello"); // true
    
    // ------------------------
    
    String c1 = "ab";
    String c2 = c1 + "c";
    System.out.println(c2 == "abc");  // false
    
}

前面四個(gè)輸出其實(shí)很容易理解，最終的結(jié)果，都指向了constant pool里的一個(gè)常量"hello"。但奇怪的是，最后一個(gè)輸出也是"abc"，并且還都是用指向constant pool中常量的變量來做的拼接，但卻得到了一個(gè)false的結(jié)果。

原因是，Java的String拼接有兩個(gè)規(guī)則：

對于拼接的值，如果都是雙引號(hào)包裹字符串的形式，則將結(jié)果放于constant pool，如果constant pool已經(jīng)有這個(gè)值了，則直接返回這個(gè)已有值。

而如果拼接的值中，有一個(gè)是非雙引號(hào)包裹字符串的形式，則從heap中開辟一個(gè)新的區(qū)域保存常量。也即是使用了String變量來做拼接的情況。

在這樣的大原則下，對聲明為final的String變量需要做更多的考慮：

如果String變量被聲明為final時(shí)就已經(jīng)被賦值，則它被編譯器自動(dòng)處理為常量，因而它就會(huì)被當(dāng)作常量池的變量來處理。

public class ConstantPool {
    public static final String s1 = "ab";
    public static final String s2 = "cd";
    
    public static void main(String... args) {
        String s = s1 + s2;
        String ss = "abcd";
        
        System.out.println(s == ss);  // true
    }
}

而如果聲明為final的字符串沒有在聲明時(shí)被賦值，則編譯器無法事先決定它的準(zhǔn)確值，所以依舊會(huì)把它當(dāng)作一個(gè)變量來處理。

public class ConstantPool {
    public static final String s1;
    public static final String s2;
    
    static {
        s1 = "ab";
        s2 = "cd";
    }
    
    public static void main(String... args) {
        String s = s1 + s2;
        String ss = "abcd";
        
        System.out.println(s == ss);  // false
    }
}

3. intern()方法

String.intern()方法，可以在runtime期間將常量加入到常量池（constant pool）。它的運(yùn)作方式是：

如果constant pool中存在一個(gè)常量恰好等于這個(gè)字符串的值，則inter()方法返回這個(gè)存在于constant pool中的常量的引用。

如果constant pool不存在常量恰好等于這個(gè)字符串的值，則在constant pool中創(chuàng)建一個(gè)新的常量，并將這個(gè)字符串的值賦予這個(gè)新創(chuàng)建的在constant pool中的常量。intern()方法返回這個(gè)新創(chuàng)建的常量的引用。

示例：

public static void main(String... args) {
    String s1 = "abcd";
    String s2 = new String("abcd");

    /**
     * s2.intern() will first search String constant pool,
     * of which the value is the same as s2.
     */
    String s3 = s2.intern();
    // As s1 comes from constant pool, and s3 is also comes from constant pool, they"re same.
    System.out.println(s1 == s3);
    // As s2 comes from heap but s3 comes from constant pool, they"re different.
    System.out.println(s2 == s3); 
}

/**
 * Output:
 *     true
 *     false
 */

回顧到最開始的第一部分，為什么要引入intern()這個(gè)函數(shù)呢？就是因?yàn)?，雖然"abcd"是被分配在constant pool里的，但是，一旦使用new String("abcd")就會(huì)在heap中新創(chuàng)建一個(gè)值為abcd的對象出來。試想，如果有100個(gè)這樣的語句，豈不是就要在heap里創(chuàng)建100個(gè)同樣值的對象？！這就造成了運(yùn)行的低效和空間的浪費(fèi)。

于是，如果引入了intern()它就會(huì)直接去constant pool找尋是否有值相同的String對象，這就極大地節(jié)省了空間也提高了運(yùn)行效率。