String、StringBuffer與StringBuilder之間的差別

一：String

　　首先String是字元串常量；也就是不可改變的對象。對于這句話的了解你可能會産生這樣一個疑問 ，不過我們可以寫一個測試代碼來加深了解

1 package string_stringBuffer_stringBuilder;
 2 
 3 public class Test1 {
 4     public static void main(String[] args) {
 5         String a="a";
 6         String b="a";
 7         System.out.println(a==b);
 8         a=a+"kk";
 9         System.out.println(a==b);
10     }
11 }      

 　　可以這樣了解這個代碼：首先運作String a="a";JVM會在常量區建立一塊記憶體區域，裡面存放字元“a”,由a這個句柄引用這塊記憶體區域，然後執行String b="a";，JVM會先在記憶體中搜尋是不是有“a”這個值是不是在哪一塊記憶體中存放着，是的話就用新的一句柄去引用那個那塊記憶體，沒有找到的話就新建立一塊記憶體然後用句柄引用，很明顯上面的代碼是找到了，然後把b也指向了“a”這塊記憶體，是以說在第一次輸出a==b時是ture，因為兩個句柄指向的是一塊記憶體；

　　但是在執行a=a+"kk";這句話的時候，JVM會去尋找是不是有存放“akk”值的記憶體，有的話就指向那塊記憶體，沒有的話就新建立再指向，是以說a這個句柄是換了一塊記憶體指向的，是以說在第二次輸出的時候是false；

　　由此可說String類型是不可改變的對象了，由于這種機制，每當用String操作字元串時，實際上是在不斷的建立新的對象，而原來的對象就會變為垃圾被ＧＣ回收掉，可想而知這樣執行效率會有多底。

 不過有一個特例：

 1 String a="a"+"b"+"c"+"d"; 

 這段代碼在執行的時候JVM會對代碼進行一個優化，變成  String a="abcd";

 但大家這裡要注意的是，如果你的字元串是來自另外的String對象的話JVM還是會按原來的方式執行；

 String 常用方法：

1 1.擷取：
 2         1）擷取字元串str長度
 3                 int i = str.length();
 4         2)根據位置（index)擷取字元
 5                 char  c = str.charAt(index);
 6         3)擷取字元在字元串中的位置
 7                 int i =str.indexOf(char ch);  //擷取的是第一次出現的位置
 8                 int i =str.indexOf(char ch ,int index);  //從位置index後擷取ch出現的第一次的位置
 9                 int  i =str.indexOf(str1) ;// 擷取str1 在str 第一次出現的位置
10                 int i=str.indexOf(str1, index0);//擷取從index位置後str第一次出現的位置
11                 int i = str.lastIndexOf(ch或者 str1)  //擷取ch或者str1最後出現的位置
12 
13 2.判斷
14         1)判斷是否以指定字元串str1開頭、結尾
15                 boolean b = str.startWith(str1)  //開頭
16                 boolean b = str.endsWith(str1) //結尾
17         2)判斷是否包含某一子串
18                 boolean b = str.contains(str1)
19         3)判斷字元串是否有内容
20                 boolean b = str.isEmpty();
21         4)忽略大小寫判斷字元串是否相同
22                 boolean b = str.equalsIgnoreCase(str1);
23 
24 3.轉換
25         1)将字元數組 -char[] ch- 轉化成字元串
26             i.  String str =new String(ch); //将整個數組變成字元串
27             ii. String str =new String(ch,offset,count)
28     //将字元數組中的offset位置之後的count個元素轉換成字元串  
29             1. String str =String.valueOf(ch);
30             2. String str =String.copyValueOf(ch,offset,count);
31             3. String str =String.copyValueOf(ch);
32         2)将字元串轉化為字元數組
33             char[] ch = str.toCharAarray();
34         3)将位元組數組轉換為字元串
35             同上1) 傳入類型變為Byte[];
36         4)将字元串轉換為位元組數組
37             Byte[] b = str.toByteArray();
38         5)将基本資料類型裝換成字元串
39             String str = String.valueOf(基本資料類型資料)；
40             若是整形資料可以用 字元串連接配接符 + "" 
41             eg :  String  str = 5+"";
42             得到字元串 “5”   
43 
44 4.替換   replace();
45         str.replace(oldchar,newchar)//将str裡oldchar變為newchar
46         str.replace(str1,str2)//将str中str1，變為str2
47 
48 5.切割   split();
49         String[]  str1 = str.split(","); //将str用 ","分割成String數組
50 
51 6.子串
52         String s = str.substring(begin);
53         // s 為 str 從begin位置到最後的字元串
54         String s = str.substring(begin,end)
55         //s 是 str 從begin 位置到end 位置的字元串
56 
57 7.轉換大小寫：
58         String s1 = str. toUpperCase(); //将str變成大寫字母
59         String s2 = str. toLowerCase(); //将str變成小寫字母
60     除去空格：
61         String s =str.trim();
62     比較：
63         int i = str.compareTo(str1);      

 二：StringBuffer

 　　StringBuffer是字元串變量：StringBuffer類中的方法主要偏重于對于字元串的變化，例如追加、插入和删除等，這個也是StringBuffer和String類的主要差別。

 　　StringBuffer類和String一樣，也用來代表字元串，隻是由于StringBuffer的内部實作方式和String不同，是以StringBuffer在進行字元串處理時，不生成新的對象，在記憶體使用上要優于String類。

　　是以在實際使用時，如果經常需要對一個字元串進行修改，例如插入、删除等操作，使用StringBuffer要更加适合一些。在StringBuffer類中存在很多和String類一樣的方法，這些方法在功能上和String類中的功能是完全一樣的。但是有一個最顯著的差別在于，對于StringBuffer對象的每次修改都會改變對象自身，這點是和String類最大的差別。另外由于StringBuffer是線程安全的，更适合在多線程下通路；

 常用的方法：

1     /***StringBuffer        是一個容器，長度可變，可以直接操作字元串，用toString方法變為字元串 **/
 2 1.存儲
 3         1)append(); //将指定資料加在容器末尾,傳回值也是StringBuffer
 4         eg:
 5         StringBuffer sb = new StringBuffer(//可以加str);
 6         StringBuffer sb1=ab.append(資料） //資料可以任何基本資料類型
 7     注：此時sb == sb1他們是同一對象，意思是可以不用建立sb1直接 sb.append(資料) 使用時之後接使用sb
 8 
 9 
10 2)insert();// 插入
11     sb.insert(index ,資料);
12 
13 2.删除
14         sb.delete(start ,end);  //删除start到end的字元内容
15 //注意：這裡的所有包含index的操作都是含頭不含尾的
16         sb.deleteCharAt(index);//删除指定位置的字元
17 //清空StringBuffer緩沖區
18         sb=new StringBuffer();
19         sb.delete(0,sb.length());
20 
21 3.擷取
22     char c = sb.charAt(index);//擷取index上的字元
23     int i = sb.indexOf(char)://擷取char字元出現的第一次位置
24     //與 String 中的擷取方法一緻參考前面
25 
26 4.修改                  String類中無次操作方法
27     sb =sb.replace(start,end,string)//将從start開始到end的字元串替換為string；
28     sb.setCharAr(index ,char);//将index位置的字元變為新的char
29 
30 5.反轉     sb.reverse();//将sb倒序
31 6. getChars(int srcBegin,int srcEnd,char[] ch,int chBegin)
32 //将StringBuffer緩沖區中的指定資料存儲到指定數組中      

 三：StringBuilder

 　　StringBuilder 和 StringBuffer 方法和功能完全一緻，隻是早期版本（StringBuffer)是線程安全的，由于發現利用多線程堆同一String資料操作的情況是很少的，為了提高效率，idk1.5以後有StringBuilder 類。意思是多線程操作同一字元串的時候用StringBuffer 是線程安全的，現在一般用StringBuilder。

四：總結

　　 1.如果要操作少量的資料用 = String;

　 　2.單線程操作字元串緩沖區 下操作大量資料 = StringBuilder;

　　 3.多線程操作字元串緩沖區 下操作大量資料 = StringBuffer;

 　　4.速度上 StringBuilder>StringBuffer>String;

歡迎大家一起說出自己的想法。