Android課程---String、StringBuffer 、StringBuilder 的區別（轉）

String 字符串常量

StringBuffer 字符串變量（線程安全）

StringBuilder 字符串變量（非線程安全）

 簡要的說， String 類型和 StringBuffer 類型的主要性能區別其實在於 String 是不可變的對象, 因此在每次對 String 類型進行改變的時候其實都等同於生成了一個新的 String 對象，然后將指針指向新的 String 對象，所以經常改變內容的字符串最好不要用 String ，因為每次生成對象都會對系統性能產生影響，特別當內存中無引用對象多了以后， JVM 的 GC 就會開始工作，那速度是一定會相當慢的。

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

 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 S1 = “This is only a” + “ simple” + “test”; 其實就是：

 String S1 = “This is only a simple test”; 所以當然不需要太多的時間了。但大家這里要注意的是，如果你的字符串是來自另外的 String 對象的話，速度就沒那么快了，譬如：

String S2 = “This is only a”;

String S3 = “ simple”;

String S4 = “ test”;

String S1 = S2 +S3 + S4;

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

在大部分情況下 StringBuffer > String

StringBuffer

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

可將字符串緩沖區安全地用於多個線程。可以在必要時對這些方法進行同步，因此任意特定實例上的所有操作就好像是以串行順序發生的，該順序與所涉及的每個線程進行的方法調用順序一致。

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

例如，如果 z 引用一個當前內容是“start”的字符串緩沖區對象，則此方法調用 z.append("le") 會使字符串緩沖區包含“startle”，而 z.insert(4, "le") 將更改字符串緩沖區，使之包含“starlet”。

在大部分情況下 StringBuilder > StringBuffer

java.lang.StringBuilde

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

    如果你讀過《Think in Java》，而且對里面描述HashTable和HashMap區別的那部分章節比較熟悉的話，你一定也明白了原因所在。對，就是支持線程同步保證線程安全而導致性能下降的問題。HashTable是線程安全的，很多方法都是synchronized方法，而HashMap不是線程安全的，但其在單線程程序中的性能比HashTable要高。StringBuffer和StringBuilder類的區別也在於此，新引入的StringBuilder類不是線程安全的，但其在單線程中的性能比StringBuffer高。如果你對此不太相信，可以試試下面的例子：

package com.hct.test;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
/**
 * @author: chengtai.he
 * @created:2009-12-9 上午09:59:57
 */
public class StringBuilderTester {
 private static final String base = " base string. ";
 private static final int count = 2000000;
 
 public static void stringTest() {
  long begin, end;
  begin = System.currentTimeMillis();
  String test = new String(base);
  for (int i = 0; i < count/100; i++) {
   test = test + " add ";
  }
  end = System.currentTimeMillis();
  System.out.println((end - begin)
    + " millis has elapsed when used String. ");
 }
 
 public static void stringBufferTest() {
  long begin, end;
  begin = System.currentTimeMillis();
  StringBuffer test = new StringBuffer(base);
  for (int i = 0; i < count; i++) {
   test = test.append(" add ");
  }
  end = System.currentTimeMillis();
  System.out.println((end - begin)
    + " millis has elapsed when used StringBuffer. ");
 }
 
 public static void stringBuilderTest() {
  long begin, end;
  begin = System.currentTimeMillis();
  StringBuilder test = new StringBuilder(base);
  for (int i = 0; i < count; i++) {
   test = test.append(" add ");
  }  
  end = System.currentTimeMillis();
  System.out.println((end - begin)
    + " millis has elapsed when used StringBuilder. ");
 }
 
 public static String appendItemsToStringBuiler(List list) {
  StringBuilder b = new StringBuilder();
 
  for (Iterator i = list.iterator(); i.hasNext();) {
   b.append(i.next()).append(" ");
  }
 
  return b.toString();
 }
 
 public static void addToStringBuilder() {
  List list = new ArrayList();
  list.add(" I ");
  list.add(" play ");
  list.add(" Bourgeois ");
  list.add(" guitars ");
  list.add(" and ");
  list.add(" Huber ");
  list.add(" banjos ");
 
  System.out.println(StringBuilderTester.appendItemsToStirngBuffer(list));
 }
 
 public static String appendItemsToStirngBuffer(List list) {
  StringBuffer b = new StringBuffer();
 
  for (Iterator i = list.iterator(); i.hasNext();) {
   b.append(i.next()).append(" ");
  }
 
  return b.toString();
 }
 
 public static void addToStringBuffer() {
  List list = new ArrayList();
  list.add(" I ");
  list.add(" play ");
  list.add(" Bourgeois ");
  list.add(" guitars ");
  list.add(" and ");
  list.add(" Huber ");
  list.add(" banjos ");
 
  System.out.println(StringBuilderTester.appendItemsToStirngBuffer(list));
 }
 
 public static void main(String[] args) {
  stringTest();
  stringBufferTest();
  stringBuilderTest();
  addToStringBuffer();
  addToStringBuilder();
 }
}
 

運行結果：

5266 millis has elapsed when used String. 
375 millis has elapsed when used StringBuffer. 
281 millis has elapsed when used StringBuilder. 
 I   play   Bourgeois   guitars   and   Huber   banjos  
 I   play   Bourgeois   guitars   and   Huber   banjos 

 

從上面的結果來看，這三個類在單線程程序中的性能差別一目了然，采用String對象時，即使運行次數僅是采用其他對象的1/100，其執行時間仍然比其他對象高出25倍以上；而采用StringBuffer對象和采用StringBuilder對象的差別也比較明顯，前者是后者的1.5倍左右。由此可見，如果我們的程序是在單線程下運行，或者是不必考慮到線程同步問題，我們應該優先使用StringBuilder類；當然，如果要保證線程安全，自然非StringBuffer莫屬了。

 

除了對多線程的支持不一樣外，這兩個類的使用幾乎沒有任何差別，上面的例子就是個很好的說明。appendItemsToStringBuiler和appendItemsToStirngBuffer兩個方法除了采用的對象分別為StringBuilder和StringBuffer外，其他完全相同，而效果也完全相同。