JAVA中String與StringBuffer的區別



String和StringBuffer的區別,網上資料可以說是數不勝數,但是看到這篇文章,感覺裏面做的小例子很有代表性,所以轉一下,並自己做了一點總結。

 

在java中有3個類來負責字符的操作。

1.Character 是進行單個字符操作的,

2.String 對一串字符進行操作。不可變類。

3.StringBuffer 也是對一串字符進行操作,但是可變類。

String:
是對象不是原始類型.
爲不可變對象,一旦被創建,就不能修改它的值.
對於已經存在的String對象的修改都是重新創建一個新的對象,然後把新的值保存進去.
String 是final類,即不能被繼承.

StringBuffer:
是一個可變對象,當對他進行修改的時候不會像String那樣重新建立對象
它只能通過構造函數來建立,
StringBuffer sb = new StringBuffer();
note:不能通過付值符號對他進行付值.
sb = "welcome to here!";//error
對象被建立以後,在內存中就會分配內存空間,並初始保存一個null.向StringBuffer
中付值的時候可以通過它的append方法.
sb.append("hello");

字符串連接操作中StringBuffer的效率要比String高:

String str = new String("welcome to ");
str += "here";
的處理步驟實際上是通過建立一個StringBuffer,讓侯調用append(),最後
再將StringBuffer toSting();
這樣的話String的連接操作就比StringBuffer多出了一些附加操作,當然效率上要打折扣.

並且由於String 對象是不可變對象,每次操作Sting 都會重新建立新的對象來保存新的值.
這樣原來的對象就沒用了,就要被垃圾回收.這也是要影響性能的. 

看看以下代碼:
將26個英文字母重複加了5000次,

  1.         String tempstr = "abcdefghijklmnopqrstuvwxyz";
  2.         int times = 5000;
  3.         long lstart1 = System.currentTimeMillis();
  4.         String str = "";
  5.         for (int i = 0; i < times; i++) {
  6.             str += tempstr;
  7.         }
  8.         long lend1 = System.currentTimeMillis();
  9.         long time = (lend1 - lstart1);
  10.         System.out.println(time);

可惜我的計算機不是超級計算機,得到的結果每次不一定一樣一般爲 46687左右。
也就是46秒。
我們再看看以下代碼

  1.         String tempstr = "abcdefghijklmnopqrstuvwxyz";
  2.         int times = 5000;
  3.         long lstart2 = System.currentTimeMillis();
  4.         StringBuffer sb = new StringBuffer();
  5.         for (int i = 0; i < times; i++) {
  6.             sb.append(tempstr);
  7.         }
  8.         long lend2 = System.currentTimeMillis();
  9.         long time2 = (lend2 - lstart2);
  10.         System.out.println(time2);

得到的結果爲 16 有時還是 0
所以結論很明顯,StringBuffer 的速度幾乎是String 上萬倍。當然這個數據不是很準確。因爲循環的次數在100000次的時候,差異更大。不信你試試。

 

根據上面所說:

str += "here";
的處理步驟實際上是通過建立一個StringBuffer,讓侯調用append(),最後
再將StringBuffer toSting();

所以str += "here";可以等同於

StringBuffer sb = new StringBuffer(str);

sb.append("here");

str = sb.toString();

所以上面直接利用"+"來連接String的代碼可以基本等同於以下代碼

  1.         String tempstr = "abcdefghijklmnopqrstuvwxyz";
  2.         int times = 5000;
  3.         long lstart2 = System.currentTimeMillis();
  4.         String str = "";
  5.         for (int i = 0; i < times; i++) {
  6.             StringBuffer sb = new StringBuffer(str);
  7.             sb.append(tempstr);
  8.             str = sb.toString();
  9.         }
  10.         long lend2 = System.currentTimeMillis();
  11.         long time2 = (lend2 - lstart2);
  12.         System.out.println(time2);

平均執行時間爲46922左右,也就是46秒。

 

總結: 如果在程序中需要對字符串進行頻繁的修改連接操作的話.使用StringBuffer性能會更高




String、StringBuffer與StringBuilder之間區別

  最近學習到StringBuffer,心中有好些疑問,搜索了一些關於String,StringBuffer,StringBuilder的東西,現在整理一下。

關於這三個類在字符串處理中的位置不言而喻,那麼他們到底有什麼優缺點,到底什麼時候該用誰呢?下面我們從以下幾點說明一下

  1.三者在執行速度方面的比較:StringBuilder >  StringBuffer  >  String

  2.String <(StringBuffer,StringBuilder)的原因

    String:字符串常量

    StringBuffer:字符創變量

    StringBuilder:字符創變量

    從上面的名字可以看到,String是“字符創常量”,也就是不可改變的對象。對於這句話的理解你可能會產生這樣一個疑問  ,比如這段代碼:

1 String s = "abcd";
2 = s+1;
3 System.out.print(s);// result : abcd1

 

       我們明明就是改變了String型的變量s的,爲什麼說是沒有改變呢? 其實這是一種欺騙,JVM是這樣解析這段代碼的:首先創建對象s,賦予一個abcd,然後再創建一個新的對象s用來    執行第二行代碼,也就是說我們之前對象s並沒有變化,所以我們說String類型是不可改變的對象了,由於這種機制,每當用String操作字符串時,實際上是在不斷的創建新的對象,而原來的對象就會變爲垃圾被GC回收掉,可想而知這樣執行效率會有多底。

     而StringBuffer與StringBuilder就不一樣了,他們是字符串變量,是可改變的對象,每當我們用它們對字符串做操作時,實際上是在一個對象上操作的,這樣就不會像String一樣創建一些而外的對象進行操作了,當然速度就快了。

  3.一個特殊的例子:

你會很驚訝的發現,生成str對象的速度簡直太快了,而這個時候StringBuffer居然速度上根本一點都不佔優勢。其實這是JVM的一個把戲,實際上:

    String str = “This is only a” + “ simple” + “test”;

    其實就是:

    String str = “This is only a simple test”;

    所以不需要太多的時間了。但大家這裏要注意的是,如果你的字符串是來自另外的String對象的話,速度就沒那麼快了,譬如:

    String str2 = “This is only a”;

    String str3 = “ simple”;

    String str4 = “ test”;

    String str1 = str2 +str3 + str4;

    這時候JVM會規規矩矩的按照原來的方式去做。

  4.StringBuilder與 StringBuffer

    StringBuilder:線程非安全的

    StringBuffer:線程安全的

    當我們在字符串緩衝去被多個線程使用是,JVM不能保證StringBuilder的操作是安全的,雖然他的速度最快,但是可以保證StringBuffer是可以正確操作的。當然大多數情況下就是我們是在單線程下進行的操作,所以大多數情況下是建議用StringBuilder而不用StringBuffer的,就是速度的原因。

 

           對於三者使用的總結: 1.如果要操作少量的數據用 = String

                        2.單線程操作字符串緩衝區 下操作大量數據 = StringBuilder

                        3.多線程操作字符串緩衝區 下操作大量數據 = StringBuffer

 

          偶是初學者,只是總結了自己學習的東西,難免寫的東西里有別人的,學習是記憶的過程,這些東西只是用來學習罷了,有些東西可能不對,希望各位給予指正。


發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章