String、StringBuffer與StringBuilde總結

  String：字元串常量

  StringBuffer：字元串變量（線程安全的）

  StringBuilder： 字元串變量（非線程安全的）

     簡要的說， String 類型和 StringBuffer 類型的主要性能差別其實在于 String 是不可變的對象, 是以在每次對 String類型進行改變的時候其實都等同于生成了一個新的 String 對象，然後将指針指向新的 String 對象，是以經常改變内容的字元串最好不要用 String ，因為每次生成對象都會對系統性能産生影響，特别當記憶體中無引用對象多了以後，JVM 的 GC 就會開始工作，那速度是一定會相當慢的。

     而如果是使用 StringBuffer 類則結果就不一樣了，每次結果都會對 StringBuffer 對象本身進行操作，而不是生成新的對象，再改變對象引用。是以在一般情況下我們推薦使用 StringBuffer ，特别是字元串對象經常改變的情況下。而在某些特别情況下， String 對象的字元串拼接其實是被 JVM 解釋成了 StringBuffer 對象的拼接，是以這些時候 String對象的速度并不會比 StringBuffer 對象慢，而特别是以下的字元串對象生成中， String 效率是遠要比 StringBuffer 快的：

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

 StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

 你會很驚訝的發現，生成 String S1 對象的速度簡直太快了，而這個時候 StringBuffer 居然速度上根本一點都不占優勢。其實這是 JVM 的一個把戲，在 JVM 眼裡，這個 String str1 = “How are” + “ you” ; 其實就是：

 String str1 = “How are you”; 是以當然不需要太多的時間了。但大家這裡要注意的是，如果你的字元串是來自

另外的 String 對象的話，速度就沒那麼快了。

譬如：

  String str2 = “How”;

  String str3 = “ are”;

  String str4 = “ you”;

  String str1 = str2 +str3 + str4;

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

StringBuffer

Java.lang.StringBuffer線程安全的可變字元序列。一個類似于 String 的字元串緩沖區，但不能修改。雖然在任意時間點上它都包含某種特定的字元序列，但通過某些方法調用可以改變該序列的長度和内容。

可将字元串緩沖區安全地用于多個線程。可以在必要時對這些方法進行同步，是以任意特定執行個體上的所有操作就好像是以串行順序發生的，該順序與所涉及的每個線程進行的方法調用順序一緻。

StringBuffer 上的主要操作是 append 和 insert 方法，可重載這些方法，以接受任意類型的資料。每個方法都能有效地将給定的資料轉換成字元串，然後将該字元串的字元追加或插入到字元串緩沖區中。append 方法始終将這些字元添加到緩沖區的末端；而 insert 方法則在指定的點添加字元。

例如，如果x 引用一個目前内容是“sequence”的字元串緩沖區對象，則此方法調用 x.append("s") 會使字元串緩沖區包含“sequences”，而 x.insert(7, "s") 将更改字元串緩沖區，使之包含“sequencse”。

在大部分情況下 StringBuffer > String

下面來做一個測試，對比String類和StringBuffer的執行效率：

String執行10000次累加

public static void main(String[] args) {
	// TODO Auto-generated method stub
	
	long start = System.currentTimeMillis(); 
	String str = ""; 
	for (int i = 0; i < 10000; i++) { 
		str += "," + i; 
	} 
	long end = System.currentTimeMillis(); 
	System.out.println(end - start);
}
           

執行的結果花費了：1028ms

使用StringBuffer類來代替String類，執行10000次累加

public static void main(String[] args) {
	// TODO Auto-generated method stub
	
	long start = System.currentTimeMillis(); 
	StringBuffer str = new StringBuffer(); 
	for (int i = 0; i < 10000; i++) { 
		str.append(",").append(i); 
	} 
	long end = System.currentTimeMillis(); 
	System.out.println(end - start); 
}
           

執行的結果隻花費了:  7ms

      通過對比發現StringBuffer幾乎不花費時間。這是因為，String對象的每一次累加，都會先将累加的字元串建立一個執行個體對象然後再累加，等于是建立了10000個執行個體。而StringBuffer每次都是修改的原有執行個體對象，隻是建立了1個執行個體。通過學習第2章我們已經知道，建立執行個體需要申請記憶體位址、寫入資料的過程，大量的這種操作就會消耗大量的CPU計算資源。

在大部分情況下 StringBuilder > StringBuffer

java.lang.StringBuilde

java.lang.StringBuilder一個可變的字元序列是5.0新增的。此類提供一個與 StringBuffer 相容的 API，但不保證同步。該類被設計用作 StringBuffer 的一個簡易替換，用在字元串緩沖區被單個線程使用的時候（這種情況很普遍）。如果可能，建議優先采用該類，因為在大多數實作中，它比 StringBuffer 要快。兩者的方法基本相同。

何時用StringBuffer、StringBuilder:

StringBuilder一般使用在方法内部來完成類似"+"功能，因為是線程不安全的,是以用完以後可以丢棄。StringBuffer要用在全局變量中。

下面以一個例子對比測試String、StringBuffer、StringBuilder三者的性能。

public class Test { 
	static int count = 500;//循環次數 
 	// 測試String 
	public static void testString() { 
		long start = System.nanoTime(); 
		String str = ""; 
		for (int i = 0; i < count; i++) { 
			str += "," + i; 
		} 
		long end = System.nanoTime(); 
		System.out.println("String：" + (end - start)); 
	} 
	
	// 測試StringBuffer 
	public static void testStringBuffer() { 
		long start = System.nanoTime(); 
		StringBuffer str = new StringBuffer(); 
		for (int i = 0; i < count; i++) { 
			str.append(",").append(i); 
		} 
		long end = System.nanoTime(); 
		System.out.println("StringBuffer：" + (end - start)); 
	} 
	
	// 測試StringBuilder 
	public static void testStringBuilder() { 
		long start = System.nanoTime(); 
		StringBuilder str = new StringBuilder(); 
		for (int i = 0; i < count; i++) { 
			str.append(",").append(i); 
		} 
		long end = System.nanoTime(); 
		System.out.println("StringBuilder：" + (end - start)); 
	} 

	public static void main(String[] args) { 
		Test.testString(); 
		Test.testStringBuffer(); 
		Test.testStringBuilder(); 
	} 
} 
           

測試結果對比如下表 ：

毫秒	String	StringBuffer	StringBuilder
1次	93,788	67,192	7,932
10次	127,850	86,322	20,531
100次	433,011	291,162	112,452
1000次	13,580,579	516,067	266,898
10000次	973,553,217	3,017,077	1,437,614

結果對比分析:

String循環1萬次所用時間約為：973ms，而StringBuffer在1萬次循環所用時間約為：3ms，StringBuilder在1萬次循環所用時間約為：1ms。顯然選擇優先級為：StringBuilder>StringBuffer>String。是以，對于這三個類的使用，我們需要按照以下情況去選擇：

  ● 如果你偶爾對簡單的字元串常量進行拼接，那麼可以使用String，它足夠簡單而且輕量級；

  ● 如果你需要經常進行字元串的拼接、累加操作，請使用StringBuffer或StringBuilder；

  ● 如果是在單線程的環境中，建議使用StringBuilder，它要比StringBuffer快；如果是在多線程的環境中，建議使用StringBuffer，它是線程安全的；

是以，StringBuilder實際上是我們的首選，隻有在多線程時才可以考慮使用StringBuffer，隻有在字元串的拼接足夠簡單時才使用String。