Java String 探索

ingood 發(fā)布于2019-08-16 10:33 / 3161人閱讀

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

今天看到了一個(gè)Java string的相關(guān)問(wèn)題，解決問(wèn)題的過(guò)程中就想把string 好好理順了，總結(jié)在這里。

== 和 equals()

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

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和StringBuffer

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

查看String的構(gòu)造函數(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());
}

可見(jiàn) 為了使buffer的線程安全性在構(gòu)造String時(shí)得到延續(xù)，加了同步塊。

String str = new String("vv"); 創(chuàng)建了幾個(gè)對(duì)象？

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

    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虛擬機(jī) 一書(shū)中看的工具）

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

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

String str = "vv"; 創(chuàng)建了幾個(gè)對(duì)象？

答案：0或1
如果常量池已經(jīng)有"vv" 對(duì)象，就直接返回引用，如果還沒(méi)有，就會(huì)放入常量池，然后返回引用。

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

可見(jiàn)s1,s2指向同一個(gè)對(duì)象。

而且常量池也有 vv

String str = "v" + "v";創(chuàng)建了幾個(gè)對(duì)象？

答案：0或1
常量字符串是在編譯的時(shí)候就被確定的,"v"是常量，所以編譯時(shí)確定
這個(gè)代碼編譯后與 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
        }
    }

可見(jiàn) s1,s2 指向同一個(gè)對(duì)象

String str = s1 + s2;創(chuàng)建了幾個(gè)對(duì)象？

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

    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
        }
    }

但是如果變量是常量時(shí)，就不同了

    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
        }
    }

因?yàn)閟1是在運(yùn)行過(guò)程確定的，所以s5也只能運(yùn)行時(shí)確定；
總結(jié)起來(lái)， String str=s1+s2 創(chuàng)建幾個(gè)變量，關(guān)鍵取決于 s1,s2 能否在編譯期確定

String str = "v".concat("v");創(chuàng)建了幾個(gè)對(duì)象？

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
    }
}

可見(jiàn)concat 產(chǎn)生的變量沒(méi)有直接引用常量池的對(duì)象。

查看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)建了一個(gè) String對(duì)象。

String 和 Char[]

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

未完待續(xù)......

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

歡迎訪問(wèn)我的個(gè)人主頁(yè) mageek（mageek.cn）