摘要：今天看到了一個的相關問題，解決問題的過程中就想把好好理順了，總結在這里。查看的構造函數(shù)源碼可見為了使的線程安全性在構造時得到延續(xù)，加了同步塊。可見指向同一個對象。

今天看到了一個Java string的相關問題，解決問題的過程中就想把string 好好理順了，總結在這里。

== 是判斷兩個變量是否指向同一個對象，equals()只判斷兩個字符串內容是否相同

public class Cons {
    public static void main(String[] args) throws InterruptedException {

        String s2 = new String("vv");
        String s3 = "vv";
        System.out.println(s2 == s3);//false
        System.out.println(s3.equals(s2));//true
    }
}

String和StringBuilder：StringBuilder是可變的，也就是說用StringBuilder創(chuàng)建的字符串你可以隨時改變它。
StringBuilder和StringBuffer：StringBuffer是同步的，它是線程安全（thread-safe）的，但效率要比StringBuilder差得多。

查看String的構造函數(shù)jdk源碼：

public String(StringBuffer buffer) {
    synchronized(buffer) {
        this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
    }
}

public String(StringBuilder builder) {
    this.value = Arrays.copyOf(builder.getValue(), builder.length());
}

可見 為了使buffer的線程安全性在構造String時得到延續(xù)，加了同步塊。

答案：1或2
new String("vv")在堆中創(chuàng)建了1個實例對象，而另1個就是放在常量池中的 "vv" 對象，當然這里的str本身 只是一個引用，放在棧里，用來指向堆中創(chuàng)建出來的對象。所以如果常量池已經有"vv" 對象，就只在堆中創(chuàng)建一個對象；如果還沒有，就會放入常量池，然后再在堆中創(chuàng)建一個對象，怎么驗證呢？

    public class Cons {
        public static void main(String[] args) throws InterruptedException {
            String s1 = new String("vv");
            String s2 = "vv";
            System.out.println(s1 == s2);//false
        }
    }
    

然后用命令行工具（ 深入理解Java虛擬機 一書中看的工具）

可見常量池中有一個String 類型的 對象 vv,而且new出來的對象不是指向常量池的那個對象，亦即新創(chuàng)建了一個

注：jdk1.7 以后，虛擬機把存儲Java對象的地方定義為堆，其它地方是不會有Java對象的實體的。故常量池不再存儲對象實例，而是存儲的引用，實際對象還是在堆中，所以有所不同，下文不再贅述。

答案：0或1
如果常量池已經有"vv" 對象，就直接返回引用，如果還沒有，就會放入常量池，然后返回引用。

    public class Cons {
        public static void main(String[] args) throws InterruptedException {
            String s1 = "vv";
            String s2 = "vv";
            System.out.println(s1 == s2);//true
        }
    }

可見s1,s2指向同一個對象。

而且常量池也有 vv

答案：0或1
常量字符串是在編譯的時候就被確定的,"v"是常量，所以編譯時確定
這個代碼編譯后 與 String str = "vv"; 是一樣的

    public class Cons {
        public static void main(String[] args) throws InterruptedException {
            String s1 = "vv";
            String s2 = "v"+"v";
            System.out.println(s1 == s2);//true
        }
    }

可見 s1,s2 指向同一個對象

答案 視情況而定
“+”連接的兩個字符串本身就是字面常量字符串時，如果池中存在這樣連接后的字符串，則是不會重新創(chuàng)建對象，而是直接引用池中的字符串對象；如果“+”連接的兩字符串中只要有一個是變量，是會產生新的字符串對象。

    public class Cons {
        public static void main(String[] args) throws InterruptedException {
            String s1 = "ww";
            String s2 = "vv";
            String s3 = "vvww";
            String s4 = "vv"+"ww";
            String s5 = "vv"+s1;
            System.out.println(s3 == s4);//true
            System.out.println(s3 == s5);//false
        }
    }

但是如果變量是常量時，就不同了

    public class Cons {
        public static void main(String[] args) throws InterruptedException {
            final String  s1 = "ww";
            String s2 = "vv";
            String s3 = "vvww";
            String s4 = "vv"+"ww";
            String s5 = "vv"+s1;
            String s6 = s2+s1;
            System.out.println(s3 == s4);//true
            System.out.println(s3 == s5);//true
        }
    }

但如果先定義final字符串，但未在定義處初始化,那么又不同了，

    public class Cons {
        public static void main(String[] args) throws InterruptedException {
            final String  s1 ;
            String s2 = "vv";
            String s3 = "vvww";
            String s4 = "vv"+"ww";
            s1 = "ww";
            String s5 = "vv"+s1;
            String s6 = s2+s1;
            System.out.println(s3 == s4);//true
            System.out.println(s3 == s5);//false
        }
    }

因為s1是在運行過程確定的，所以s5也只能運行時確定；
總結起來， String str=s1+s2 創(chuàng)建幾個變量，關鍵取決于 s1,s2 能否在編譯期確定

public class Cons {
    public static void main(String[] args) throws InterruptedException {
        String s1 = new String("vv");
        String s2 = "v".concat("v");
        String s4 = "v"+"v";
        String s3 = "vv";
        System.out.println(s2 == s3);//false
        System.out.println(s1 == s3);//false
        System.out.println(s4 == s3);//true
    }
}

可見concat 產生的變量沒有直接引用常量池的對象。

查看jdk8源碼

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

果然是新創(chuàng)建了一個 String對象。

查看jdk源碼，知道 String的內部實現(xiàn)就是一個 Char 數(shù)組， 說String 不可變，也是因為 這個數(shù)組就是一個final 類型的 變量。

參考
http://jiangzhengjun.iteye.co...
《深入理解Java虛擬機》

歡迎訪問我的個人主頁 mageek（mageek.cn）