亚洲免费在线-亚洲免费在线播放-亚洲免费在线观看-亚洲免费在线观看视频-亚洲免费在线看-亚洲免费在线视频

String和StringBuffer詳解

系統 1614 0

String的創建

??? String s = "hello";
??? JVM先根據內容"hello"查找對象,如果沒有找到,則在heap上創建新對象,并將其賦予s1,否則使用已經存在的對象

??? String s = new String("hello");
??? JVM直接在heap上創建新的對象,所以在heap中會出現內容相同,地址不同的String對象


String的比較

??? "=="????????? 比較地址
??? "equals"????? 比較內容

??? 舉例:
??? String s1 = "hello";
??? String s2 = "hello";
??? String s3 = new String("hello");

??? s1 == s2;???????????????? // true????????? 地址相同
??? s1 == s3;???????????????? // false???????? 地址不同
??? s1.equals(s2);??????????? // true????????? 內容相同
??? s1.equals(s3);??????????? // true????????? 內容相同


intern() 方法

???? 查找內容相同(equals())的字符串

???? String s1 = "hello";????????????????? // hello不存在,jvm創建新對象 (1)
???? String s2 = new String("hello");????? // 創舉新對象 (2),這時heap中存在兩個內容為hello的對象
???? s1 == s2;???????????? // false????????? // 地址不同
???? s1.equals(s2);??????? // true?????????? // 內容相同
???? s2 = s2.intern();???? // true?????????? // 找到對象(1) 并賦予s2
???? s1 == s2;???????????? // true !!??????? // 注意:此時s1,s2同指向(1)


效率:String 與 StringBuffer

????? 情景1:
????? (1) String result = "hello" + " world";
????? (2) StringBuffer result = new String().append("hello").append(" world");

????????? (1) 的效率好于 (2),不要奇怪,這是因為JVM會做如下處理
????????? 編譯前???? String result = "hello" + " world";
????????? 編譯后???? String result = "hello world";


????? 情景2:
????? (1) public String getString(String s1, String s2) {
????????????? return s1 + s2;
????????? }
????? (2) public String getString(String s1, String s2) {
????????????? return new StringBuffer().append(s1).append(s2);
????????? }

????????? (1) 的效率與 (2) 一樣,這是因為JVM會做如下處理
????????? 編譯前???? return s1 + s2;
????????? 編譯后???? return new StringBuffer().append(s1).append(s2);


????? 情景3:
????? (1) String s = "s1";
??????????????? s += "s2";
??????????????? s += "s3";
????? (2) StringBuffer s = new StringBuffer().append("s1").append("s2").append("s3");

????????? (2) 的效率好于(1),因為String是不可變對象,每次"+="操作都會造成構造新的String對象


????? 情景4:
????? (1) StringBuffer s = new StringBuffer();
????????? for (int i = 0; i < 50000; i ++) {
????????????? s.append("hello");
????????? }
????? (2) StringBuffer s = new StringBuffer(250000);
????????? for (int i = 0; i < 50000; i ++) {
????????????? s.append("hello");
????????? }
???????
????????? (2) 的效率好于 (1),因為StringBuffer內部實現是char數組,默認初始化長度為16,每當字符串長度大于char
????????? 數組長度的時候,JVM會構造更大的新數組,并將原先的數組內容復制到新數組,(2)避免了復制數組的開銷
????????
????


關鍵點
????? 1). 簡單的認為 .append() 效率好于 "+" 是錯誤的!
????? 2). 不要使用 new 創建 String
????? 3). 注意 .intern() 的使用
????? 4). 在編譯期能夠確定字符串值的情況下,使用"+"效率最高
????? 5). 避免使用 "+=" 來構造字符串
????? 6). 在聲明StringBuffer對象的時候,指定合適的capacity,不要使用默認值(18)
????? 7). 注意以下二者的區別不一樣
????????? - String s = "a" + "b";
????????? - String s = "a";
??????????? s += "b";

?

String和StringBuffer之概覽
  創建字符串的較佳途徑
  滯留字符串帶來的優化
  連接字符串時的優化技巧
  借助StringBuffer的初始化過程的優化技巧
  關鍵點

String和StringBuffer之概覽
  非可變對象一旦創建之后就不能再被改變,可變對象則可以在創建之后被改變。String對象是非可變對象,StringBuffer對象則是可變對象。為獲得更佳的性能你需要根據實際情況小心謹慎地選擇到底使用這兩者中的某一個。下面的話題會作詳細的闡述。(注意:這個章節假設讀者已經具備Java的String和StringBuffer的相關基礎知識。)
創建字符串的較佳途徑
你可以按照以下方式創建字符串對象:
1. String s1 = "hello";
????? String s2 = "hello";
2. String s3 = new String("hello");
????? String s4 = new String("hello");
上面哪種方式會帶來更好的性能呢?下面的代碼片斷用來測量二者之間的區別。

StringTest1.java
package com.performance.string;
/** This class shows the time taken for creation of
*??? String literals and String objects.
*/
public class StringTest1 {
public static void main(String[] args){
????? // create String literals
????? long startTime = System.currentTimeMillis();
????? for(int i=0;i<50000;i++){
????? String s1 = "hello";
????? String s2 = "hello";
????? }
????? long endTime = System.currentTimeMillis();
????? System.out.println("Time taken for creation of String literals : "
??????????????????? + (endTime - startTime) + " milli seconds" );
????? // create String objects using 'new' keyword????????
????? long startTime1 = System.currentTimeMillis();
????? for(int i=0;i<50000;i++){
????? String s3 = new String("hello");
????? String s4 = new String("hello");
????? }
????? long endTime1 = System.currentTimeMillis();
????? System.out.println("Time taken for creation of String objects : "
??????????????????? + (endTime1 - startTime1)+" milli seconds");
????? }
}

這段代碼的輸出:
Time taken for creation of String literals : 0 milli seconds
Time taken for creation of String objects : 170 milli seconds
JVM是怎樣處理字符串的呢?
  Java虛擬機會維護一個內部的滯留字符串對象的列表(唯一字符串的池)來避免在堆內存中產生重復的String對象。當JVM從class文件里加載字符串字面量并執行的時候,它會先檢查一下當前的字符串是否已經存在于滯留字符串列表,如果已經存在,那就不會再創建一個新的String對象而是將引用指向已經存在的String對象,JVM會在內部為字符串字面量作這種檢查,但并不會為通過new關鍵字創建的String對象作這種檢查。當然你可以明確地使用String.intern()方法強制JVM為通過new關鍵字創建的String對象作這樣的檢查。這樣可以強制JVM檢查內部列表而使用已有的String對象。
  所以結論是,JVM會內在地為字符串字面量維護一些唯一的String對象,程序員不需要為字符串字面量而發愁,但是可能會被一些通過new關鍵字創建的String對象而困擾,不過他們可以使用intern()方法來避免在堆內存上創建重復的String對象來改善Java的運行性能。下一小節會向大家展示更多的信息。
下圖展示了未使用intern()方法來創建字符串的情況。

  你可以自己使用==操作符和String.equals()方法來編碼測試上面提到的區別。==操作符會返回true如果一些引用指向一個相同的對象但不會判斷String對象的內容是否相同;String.equals()方法會返回true如果被操作的String對象的內容相同。對于上面的代碼會有s1==s2,因為s1和s2兩個引用指向同一個對象,對于上面的代碼,s3.equals(s4)會返回true因為兩個對象的內容都一樣為”hello”。你可以從上圖看出這種機制。在這里有三個獨立的包含了相同的內容(”hello”)的對象,實際上我們不需要這么三個獨立的對象――因為要運行它們的話既浪費時間又浪費內存。
  那么怎樣才能確保String對象不會重復呢?下一個話題會涵蓋對于內建String機制的興趣。
滯留字符串的優化作用
  同一個字符串對象被重復地創建是不必要的,String.intern()方法可以避免這種情況。下圖說明了String.intern()方法是如何工作的,String.intern()方法檢查字符串對象的存在性,如果需要的字符串對象已經存在,那么它會將引用指向已經存在的字符串對象而不是重新創建一個。下圖描繪了使用了intern()方法的字符串字面量和字符串對象的創建情況。

下面的例程幫助大家了解String.intern()方法的重要性。
StringTest2.java
package com.performance.string;
// This class shows the use of intern() method to improve performance
public class StringTest2 {
public static void main(String[] args){
????? // create String references like s1,s2,s3...so on..
????? String variables[] = new String[50000];
????? for( int i=0;i<variables.length;i++){
????????? variables[i] = "s"+i;
????? }
????? // create String literals
????? long startTime0 = System.currentTimeMillis();
????? for(int i=0;i<variables.length;i++){
????????? variables[i] = "hello";
????? }
????? long endTime0 = System.currentTimeMillis();
????? System.out.println("Time taken for creation of String literals : "
?????????????????????????? + (endTime0 - startTime0) + " milli seconds" );
????? // create String objects using 'new' keyword????????
????? long startTime1 = System.currentTimeMillis();
????? for(int i=0;i<variables.length;i++){
????????? variables[i] = new String("hello");
????? }
????? long endTime1 = System.currentTimeMillis();
????? System.out.println("Time taken for creation of String objects with 'new' key word : "
????????????????????????? + (endTime1 - startTime1)+" milli seconds");
????? // intern String objects with intern() method????
????? long startTime2 = System.currentTimeMillis();
????? for(int i=0;i<variables.length;i++){
????????? variables[i] = new String("hello");
????????? variables[i] = variables[i].intern();
????? }
????? long endTime2 = System.currentTimeMillis();
????? System.out.println("Time taken for creation of String objects with intern(): "
????????????????????????? + (endTime2 - startTime2)+" milli seconds");
????? }
}
這是上面那段代碼的輸出結果:
Time taken for creation of String literals : 0 milli seconds
Time taken for creation of String objects with 'new' key word : 160 milli seconds
Time taken for creation of String objects with intern(): 60 milli seconds
連接字符串時候的優化技巧
  你可以使用+操作符或者String.concat()或者StringBuffer.append()等辦法來連接多個字符串,那一種辦法具有最佳的性能呢?
  如何作出選擇取決于兩種情景,第一種情景是需要連接的字符串是在編譯期決定的還是在運行期決定的,第二種情景是你使用的是StringBuffer還是String。通常程序員會認為StringBuffer.append()方法會優于+操作符或String.concat()方法,但是在一些特定的情況下這個假想是不成立的。
1) 第一種情景:編譯期決定相對于運行期決定
請看下面的StringTest3.java代碼和輸出結果。

package com.performance.string;
/** This class shows the time taken by string concatenation at compile time and run time.*/
public class StringTest3 {
??? public static void main(String[] args){
????? //Test the String Concatination
????? long startTime = System.currentTimeMillis();
????? for(int i=0;i<5000;i++){
????? String result = "This is"+ "testing the"+ "difference"+ "between"+
????????????? "String"+ "and"+ "StringBuffer";
????? }
????? long endTime = System.currentTimeMillis();
????? System.out.println("Time taken for string concatenation using + operator : "
?????????? + (endTime - startTime)+ " milli seconds");
????? //Test the StringBuffer Concatination
????? long startTime1 = System.currentTimeMillis();
????? for(int i=0;i<5000;i++){
????? StringBuffer result = new StringBuffer();
?????????? result.append("This is");
????????? result.append("testing the");
????????? result.append("difference");
????????? result.append("between");
???????? result.append("String");
???????? result.append("and");
???????? result.append("StringBuffer");
?????? }
????? long endTime1 = System.currentTimeMillis();
????? System.out.println("Time taken for String concatenation using StringBuffer : "
???????????? + (endTime1 - startTime1)+ " milli seconds");
??? }
}
這是上面的代碼的輸出結果:
Time taken for String concatenation using + operator : 0 milli seconds
Time taken for String concatenation using StringBuffer : 50 milli seconds

很有趣地,+操作符居然比StringBuffer.append()方法要快,為什么呢?
  這里編譯器的優化起了關鍵作用,編譯器像下面舉例的那樣簡單地在編譯期連接多個字符串。它使用編譯期決定取代運行期決定,在你使用new關鍵字來創建String對象的時候也是如此。
編譯前:
String result = "This is"+"testing the"+"difference"+"between"+"String"+"and"+"StringBuffer";
編譯后:
String result = "This is testing the difference between String and StringBuffer";

這里String對象在編譯期就決定了而StringBuffer對象是在運行期決定的。運行期決定需要額外的開銷當字符串的值無法預先知道的時候,編譯期決定作用于字符串的值可以預先知道的時候,下面是一個例子。
編譯前:
public String getString(String str1,String str2) {
????? return str1+str2;
}
編譯后:
return new StringBuffer().append(str1).append(str2).toString();
運行期決定需要更多的時間來運行。
2) 第二種情景:使用StringBuffer取代String
看看下面的代碼你會發現與情景一相反的結果――連接多個字符串的時候StringBuffer要比String快。
StringTest4.java
package com.performance.string;
/** This class shows the time taken by string concatenation
using + operator and StringBuffer??? */
public class StringTest4 {
public static void main(String[] args){
????? //Test the String Concatenation using + operator
????? long startTime = System.currentTimeMillis();
????? String result = "hello";
????? for(int i=0;i<1500;i++){
????????? result += "hello";
????? }
????? long endTime = System.currentTimeMillis();
????? System.out.println("Time taken for string concatenation using + operator : "
??????????????????? + (endTime - startTime)+ " milli seconds");
????? //Test the String Concatenation using StringBuffer
????? long startTime1 = System.currentTimeMillis();
????? StringBuffer result1 = new StringBuffer("hello");
????? for(int i=0;i<1500;i++){
????????? result1.append("hello");
????? }
????? long endTime1 = System.currentTimeMillis();
????? System.out.println("Time taken for string concatenation using StringBuffer :??? "
??????????????????? + (endTime1 - startTime1)+ " milli seconds");
????? }
}
這是上面的代碼的輸出結果:
Time taken for string concatenation using + operator : 280 milli seconds
Time taken for String concatenation using StringBuffer : 0 milli seconds
看得出StringBuffer.append()方法要比+操作符要快得多,為什么呢?

  原因是兩者都是在運行期決定字符串對象,但是+操作符使用不同于StringBuffer.append()的規則通過String和StringBuffer來完成字符串連接操作。(譯注:什么樣的規則呢?)
借助StringBuffer的初始化過程的優化技巧
  你可以通過StringBuffer的構造函數來設定它的初始化容量,這樣可以明顯地提升性能。這里提到的構造函數是StringBuffer(int length),length參數表示當前的StringBuffer能保持的字符數量。你也可以使用ensureCapacity(int minimumcapacity)方法在StringBuffer對象創建之后設置它的容量。首先我們看看StringBuffer的缺省行為,然后再找出一條更好的提升性能的途徑。
StringBuffer的缺省行為:
  StringBuffer在內部維護一個字符數組,當你使用缺省的構造函數來創建StringBuffer對象的時候,因為沒有設置初始化字符長度,StringBuffer的容量被初始化為16個字符,也就是說缺省容量就是16個字符。當StringBuffer達到最大容量的時候,它會將自身容量增加到當前的2倍再加2,也就是(2*舊值+2)。
  如果你使用缺省值,初始化之后接著往里面追加字符,在你追加到第16個字符的時候它會將容量增加到34(2*16+2),當追加到34個字符的時候就會將容量增加到70(2*34+2)。無論何事只要StringBuffer到達它的最大容量它就不得不創建一個新的字符數組然后重新將舊字符和新字符都拷貝一遍――這也太昂貴了點。所以總是給StringBuffer設置一個合理的初始化容量值是錯不了的,這樣會帶來立竿見影的性能增益。
  我利用兩個StringBuffer重新測試了上面的StringTest4.java代碼,一個未使用初始化容量值而另一個使用了。這次我追加了50000個’hello’對象沒有使用+操作符。區別是我使用StringBuffer(250000)的構造函數來初始化第二個StringBuffer了。
輸出結果如下:
Time taken for String concatenation using StringBuffer with out setting size: 280 milli seconds
Time taken for String concatenation using StringBuffer with setting size: 0 milli seconds
StringBuffer初始化過程的調整的作用由此可見一斑。所以,使用一個合適的容量值來初始化StringBuffer永遠都是一個最佳的建議。
關鍵點
1. 無論何時只要可能的話使用字符串字面量來常見字符串而不是使用new關鍵字來創建字符串。
2. 無論何時當你要使用new關鍵字來創建很多內容重復的字符串的話,請使用String.intern()方法。
3. +操作符會為字符串連接提供最佳的性能――當字符串是在編譯期決定的時候。
4. 如果字符串在運行期決定,使用一個合適的初期容量值初始化的StringBuffer會為字符串連接提供最佳的性能。
String與StringBuffer的比較
String類提供了一些方法,用來進行字符串的比較。這個類實現了Object父類的equals()方法,用來比較兩種字符串的值是否相等。同時還增加了equalsIgnoreCase()方法可以忽略兩個字符串大小寫的區別。下面是這兩種方法的例子。
【例6-6】
public class E6_6{
public static void main(String args[]) {
??? String s1="a";
??? String s2=new String("a");
??? String s3="A";
??? System.out.println(s1.equals(s2));
??? System.out.println(s1.equals(s3));
??? System.out.println(s1.equalsIgnoreCase(s3));
}
}
上例的輸出是
true
flase
true

但是StringBuffer類并沒有實現Objcet類的Equals方法,所以不能用這個方法來比較兩個StringBuffer類的字符串是否相等,如下例所示。
【例6-7】
public class E6_7{
public static void main(String args[]) {
??? StringBuffer s1=new StringBuffer("a");
??? StringBuffer s2=new StringBuffer("a");
??? System.out.println(s1.equals(s2));
??
}
}
程序輸出:false

除了用equalse方法來比較兩個字符串外,還可以用==來比較字符串。與equalse方法不同的是,==不是比較兩個字符串的值是否相等,而是比較幾個字符串的引用是否指向同一個實例。如例6-8所示。
【例6-8】
public class E6_8{
public static void main(String args[]) {
??? String s1="a";
??? String s2="a";
??? String s3=new String("a");
??? String s4=new String("a");
??? System.out.println(s1==s2);
??? System.out.println(s3==s4);
??? System.out.println(s1==s3);
??
}

}
上面的程序段輸出:
true
false
false
與上例進行比較,不僅可以看出來==與equals的區別,還可以看到字面量的String的特殊之外。
對于字面量的String,只要字符串的值是相等的,不論有多少個引用都是指向同一塊內存,不再另外分配空間。而用new關鍵字生成的實例則不同,每當用new實例化一次,分配該實例自己的內存空間。上例的存儲方式如圖所示:


圖6-1??? s1、s2、s3、s4的區別
下面再通過另一個例子來看String和StringBuffer的區別。
【例6-9】
public class E6_9{
public static void main(String args[]) {
??? String s1="a";
??? StringBuffer sb1=new StringBuffer("a");
??
??? StringBuffer sb2=sb1;
??? String s2="a"+"b";
??? sb1.append("b");
????
??? System.out.println(s1==s2);
??? System.out.println(sb1==sb2);
??
}
}
上例輸出的是:
flase
true
上例可以證明這樣的結論:String是不可變長的字符串,對String做任何的修改將生成新的字符串,而StringBuffer是可變長的字符串,不論怎么更動還是同一個字符串。

String和StringBuffer詳解


更多文章、技術交流、商務合作、聯系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號聯系: 360901061

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點擊下面給點支持吧,站長非常感激您!手機微信長按不能支付解決辦法:請將微信支付二維碼保存到相冊,切換到微信,然后點擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對您有幫助就好】

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長會非常 感謝您的哦!!!

發表我的評論
最新評論 總共0條評論
主站蜘蛛池模板: 中文一区二区视频 | 中文字幕一区在线观看 | 成人国产三级在线播放 | 尹人香蕉网在线观看视频 | 久久女同互慰一区二区三区 | 成人免费一区二区三区在线观看 | 国产成人刺激视频在线观看 | 亚洲综合无码一区二区 | 啊用力嗯快国产在线观看 | 91福利社| 久久99久久精品久久久久久 | 亚洲精品九色在线网站 | 青青青青青国产免费观看 | 四虎永久免费地址在线观看 | 国产一区二区精品久久岳 | 国产精品视频免费看 | 伊人免费视频 | 欧美人与动人物a级网站 | 俺来也欧美亚洲a∨在线 | 天天射狠狠干 | 久青草免费视频 | 欧美一级毛片图 | 久青草国产在线 | 99久久99这里只有免费费精品 | 亚洲一级片免费 | 欧美一级毛片一免费 | 日韩成人免费 | 国产精品乱码免费一区二区 | 91av国产精品 | 日韩一区二区三区不卡视频 | 国产精品久久久久久久牛牛 | 四虎精品久久 | 99久久综合久中文字幕 | 国产日日操 | 国产精品视频九九九 | 亚洲成人播放 | 奇米成人网 | 草草国产成人免费视频 | 伦理自拍 | a色毛片免费视频 | 色www国产阿娇 |