Java中String是一個特殊的包裝類數據有兩種創建形式:
1. String s = "abc";
2. String s = new String("abc");
第一種先在棧中創建一個對String類的對象引用變量s,然後去查找"abc"是否被保存在字符串常量池中,如果沒有則在棧中創建三個char型的值'a'、'b'、'c',然後在堆中創建一個String對象object,它的值是剛纔在棧中創建的三個char型值組成的數組{'a'、'b'、'c'},接着這個String對象object被存放進字符串常量池,最後將s指向這個對象的地址,如果"abc"已經被保存在字符串常量池中,則在字符串常量池中找到值爲"abc"的對象object,然後將s指向這個對象的地址。
第一種特點:JVM會自動根據棧中數據的實際情況來決定是否有必要創建新對象。
第二種可以分解成兩步1、String object = "abc"; 2、String s = new String(object); 第一步參考第一種創建方式,而第二步由於"abc"已經被創建並保存到字符串常量池中,因此jvm只會在堆中新創建一個String對象,它的值共享棧中已有的三個char型值。
第二種特點:一概在堆中創建新對象,而不管其字符串值是否相等,是否有必要創建新對象。
在講字符串比較前,必須要了解==和equals的區別:
因爲java所有類都繼承於Object基類,而Object中equals用==來實現,所以equals和==是一樣的,都是比較對象地址,java api裏的類大部分都重寫了equals方法,包括基本數據類型的封裝類、String類等。對於String類==用於比較兩個String對象的地址,equals則用於比較兩個String對象的內容(值)。
例1:字符串常量池的使用
String s0 = "abc";
String s1 = "abc";
System.out.println(s0==s1); //true 可以看出s0和s1是指向同一個對象的。
例2:String中==與equals的區別
String s0 =new String ("abc");
String s1 =new String ("abc");
System.out.println(s0==s1); //false 可以看出用new的方式是生成不同的對象
System.out.println(s0.equals(s1)); //true 可以看出equals比較的是兩個String對象的內容(值)
例3:編譯期確定
String s0="helloworld";
String s1="helloworld";
String s2="hello" + "word";
System.out.println( s0==s1 ); //true 可以看出s0跟s1是同一個對象
System.out.println( s0==s2 ); //false可以看出s0跟s2不是同一個對象
分析:因爲例子中的 s0和s1中的"helloworld”都是字符串常量,它們在編譯期就被確定了,所以s0==s1爲true;而"hello”和"world”也都是字符串常量,當一個字符串由多個字符串常量連接而成時,它自己肯定也是字符串常量,所以s2也同樣在編譯期就被解析爲一個字符串常量,所以s2也是常量池中"helloworld”的一個引用。所以我們得出s0==s1==s2;
例4:編譯期無法確定
String s0="helloworld";
String s1=new String("helloworld");
String s2="hello" + newString("world");
System.out.println( s0==s1 ); //false
System.out.println( s0==s2 ); //false
System.out.println( s1==s2 ); //false
分析:用new String() 創建的字符串不是常量,不能在編譯期就確定,所以newString() 創建的字符串不放入常量池中,它們有自己的地址空間。
s0還是常量池中"helloworld”的引用,s1因爲無法在編譯期確定,所以是運行時創建的新對象"helloworld”的引用,s2因爲有後半部分new String(”world”)所以也無法在編譯期確定,所以也是一個新創建對象"helloworld”的引用;
例5:編譯期優化
String s0 = "a1";
String s1 = "a" + 1;
System.out.println((s0 == s1)); //result = true
String s2 = "atrue";
String s3= "a" + "true";
System.out.println((s2 == s3)); //result = true
String s4 = "a3.4";
String s5 = "a" + 3.4;
System.out.println((a == b)); //result = true
分析:在程序編譯期,JVM就將常量字符串的"+"連接優化爲連接後的值,拿"a" + 1來說,經編譯器優化後在class中就已經是a1。在編譯期其字符串常量的值就確定下來,故上面程序最終的結果都爲true。
例6:編譯期無法確定
String s0 = "ab";
String s1 = "b";
String s2 = "a" + s1;
System.out.println((s0 == s2)); //result = false
分析:JVM對於字符串引用,由於在字符串的"+"連接中,有字符串引用存在,而引用的值在程序編譯期是無法確定的,即"a" + s1無法被編譯器優化,只有在程序運行期來動態分配並將連接後的新地址賦給s2。所以上面程序的結果也就爲false。
例7:編譯期確定
String s0 = "ab";
final String s1 = "b";
String s2 = "a" + s1;
System.out.println((s0 == s2)); //result = true
分析:和[6]中唯一不同的是s1字符串加了final修飾,對於final修飾的變量,它在編譯時被解析爲常量值的一個本地拷貝存儲到自己的常量 池中或嵌入到它的字節碼流中。所以此時的"a" + s1和"a" +"b"效果是一樣的。故上面程序的結果爲true。
例8:編譯期無法確定
String s0 = "ab";
final String s1 = getS1();
String s2 = "a" + s1;
System.out.println((s0 == s2)); //result = false
private static String getS1() { return "b"; }
分析:JVM對於字符串引用s1,它的值在編譯期無法確定,只有在程序運行期調用方法後,將方法的返回值和"a"來動態連接並分配地址爲s2,故上面 程序的結果爲false。
關於String的不可變設計:
String是不可改變類(記:基本類型的包裝類都是不可改變的)的典型代表,也是Immutable設計模式的典型應用,String變量一旦初始化後就不能更改,禁止改變對象的狀態,從而增加共享對象的堅固性、減少對象訪問的錯誤,同時還避免了在多線程共享時進行同步的需要。
Immutable模式的實現主要有以下兩個要點:
1.除了構造函數之外,不應該有其它任何函數(至少是任何public函數)修改任何成員變量。
2.任何使成員變量獲得新值的函數都應該將新的值保存在新的對象中,而保持原來的對象不被修改。
String的不可變性導致字符串變量使用+號的代價:
例9:
String s = “a” + "b” + "c”;
String s1 = "a";
String s2 = "b";
String s3 = "c";
String s4 = s1 + s2 + s3;
分析:變量s的創建等價於 String s = “abc”; 由上面例子可知編譯器進行了優化,這裏只創建了一個對象。由上面的例子也可以知道s4不能在編譯期進行優化,其對象創建相當於:
StringBuffer temp = newStringBuffer();
temp.append(s1).append(s2).append(s3);
String s = temp.toString();
由上面的分析結果,可就不難推斷出String 採用連接運算符(+)效率低下原因分析,形如這樣的代碼:
public class Test {
public static voidmain(String args[]) {
String s = null;
for(inti = 0; i < 100; i++) {
s+= "a";
}
}
}
每做一次 + 就產生個StringBuffer對象,然後append後就扔掉。下次循環再到達時重新產生個StringBuffer對象,然後append 字符串,如此循環直至結束。如果我們直接採用StringBuffer對象進行append的話,我們可以節省N - 1次創建和銷燬對象的時間。所以對於在循環中要進行字符串連接的應用,一般都是用StringBuffer或StringBulider對象來進行append操作。