java String、StringBuffer、StringBuilder

 1. 簡介

String是不可變類，且是線程安全的；

StringBuffer是可變類，且是線程安全的；

StringBuilder是可變類，且不是線程安全的。

注：「可變/不可變」指對該類對象進行修改操做時，是否會產生新的對象。對String對象進行修改時會產生新的對象，

對StringBuffer和StringBuilder對象修改時不會產生新的對象。

String類的定義以下，使用了final關鍵字：

1 /** The value is used for character storage. */
2 private final char value[];
3 
4 /** The offset is the first index of the storage that is used. */
5 private final int offset;
6 
7 /** The count is the number of characters in the String. */
8 private final int count;

View Code

2. String類經常使用方法

char charAt(int index)：返回指定索引處的 char 值；

int indexOf(int ch)：返回指定字符的索引（第一次出現）；

int indexOf(int ch, int fromIndex)：從指定索引開始查詢字符串中第一次出現的給定字符的索引；

int indexOf(String str)：返回給定字符串第一次出現的索引；

int indexOf(String str, int fromIndex)：從指定索引開始查詢字符串中第一次出現的給定字符串的索引；

int lastIndexOf(int ch)：返回指定字符最後一次出現的索引；

int lastIndexOf(int ch, int fromIndex)：返回指定字符最後一次出現的索引，從指定索引開始反向查詢；

int lastIndexOf(String str)：返回給定字符串最後一次出現的索引；

int lastIndexOf(String str, int fromIndex)：返回給定字符串最後一次出現的索引，指定開始檢索索引；

String replace(char oldChar, char newChar)：替換字符串中全部出現的指定字符，返回新字符串；

String replace(CharSequence target, CharSequence replacement)：替換字符串中全部出現的目標序列；

String substring(int beginIndex)：返回指定開始索引的子字符串（默認到結尾）；

String substring(int beginIndex, int endIndex)：返回指定開始索引和結束索引的子字符串（不包含結束值）；

byte[] getBytes()：使用默認字符集將字符串編碼爲 byte 序列，並返回一個新byte數組；

char[] toCharArray()：將字符串轉換爲一個新的字符數組；

String[] split(String regex)：根據給定正則表達式的匹配拆分此字符串；

String concat(String str)：將給定字符串拼接到該字符串末尾；

boolean contains(CharSquence s)：判斷字符串是否包含給定字符序列；

String toLowerCase()：使用默認規則將字符串中的字符小寫；

String toUpperCase()：使用默認規則將字符串中的字符大寫；

String valueOf(Object obj) ：將Object類型數據轉爲String類型數據；

String trim()：去除字符串中全部的首尾空格；

int length()：返回字符串長度；

示例代碼：

 1 import java.util.Arrays;
 2 
 3 public class StringFunc {
 4     public static void main(String[] args){
 5 
 6         String str1 = "1223";
 7 
 8         //返回指定索引的char值
 9         char s1 = str1.charAt(1);
10         System.out.println(s1);     // 2
11 
12         //返回指定字符的索引
13         int index0 = str1.indexOf('4');
14         int index1 = str1.indexOf('2');
15         int index2 = str1.indexOf('2',2);
16         System.out.println(index0+" "+index1+" "+index2);   // -1 1 2
17         int index3 = str1.indexOf("22");
18         int index4 = str1.indexOf("22",2);
19         System.out.println(index3+" "+index4);         // 1 -1
20 
21         // 判斷字符串是否包含指定字符串，須要連續（"13"不行）
22         boolean flag = str1.contains("12");
23         System.out.println(flag);
24 
25         // 替換字符串中指定的字符（會替換多個）
26         String str2 = str1.replace('2','4');
27         System.out.println(str2);         // 1443
28         // 替換目標序列（替換多個）
29         str2 = "1 2,3  45".replace(" ","");
30         System.out.println(str2);     // 12,345
31         str2 = "12121325".replace("12","");
32         System.out.println(str2);     // 1325
33 
34         //返回一個子串，指定開始/結束位置（不包含結束位置）
35         String str3 = str1.substring(1);
36         String str4 = str1.substring(1,3);
37         System.out.println(str3);          // 223
38         System.out.println(str4);         // 22
39 
40         // 字符串拼接
41         String str5 = str3.concat(str4);
42         System.out.println(str5);        // 22322
43 
44         // 將字符串轉換爲byte數組
45         byte[] b1 = str1.getBytes();
46         for(byte b:b1){
47             System.out.print(b+" ");   // 49 50 50 51
48         }
49 
50         // 字符串轉char數組
51         char[] charArray = str1.toCharArray();
52         System.out.println(Arrays.toString(charArray));   // [1, 2, 2, 3]
53 
54         // 拆分字符串
55         String[] strArray = str1.split("");
56         System.out.println(Arrays.toString(strArray));  // [1, 2, 2, 3]
57 
58         // 拆分字符串
59         String str6 = "1,2,3,4";
60         String[] arr6 = str6.split(",");
61         System.out.println(Arrays.toString(arr6));   // [1, 2, 2, 3]
62 
63     }
64 }

View Code

3. StringBuffer類經常使用方法

StringBuffer append(Object obj)：將object參數的字符串表達式添加到序列；

StringBuffer insert(int offset, Object obj)：向序列插入指定偏移量的object參數的字符串表示式；

StringBuffer delete(int start, int end)：從序列中刪除給定開始/結束索引的字符序列；

StringBuffer replace(int start, int end, String str)：使用給定字符串替換給定開始/結束索引的字符序列；

StringBuffer reverse()：返回反轉的序列；

CharSequence subSequence(int start, int end)：從序列中返回給定開始/結束索引的子序列；

String substring(int beginIndex)：返回指定開始索引的子字符串（默認到結尾）；

String substring(int beginIndex, int endIndex)：返回指定開始索引和結束索引的子字符串；

void setCharAt(int index, char ch)：序列指定索引處的字符設置爲char值；

void setLength(int newLength)：設置字符序列的長度；

int indexOf(String str)：返回指定子字符串第一次出現的字符串中的索引；

int indexOf(String str, int fromIndex)：從指定的索引處開始，返回指定子字符串第一次出現的字符串中的索引；

char charAt(int index)：返回給定索引在該序列中的char值；

int capacity()：返回當前容量；

示例代碼：

 1 public class StringBufferFunc {
 2 
 3     public static void main(String[] args){
 4 
 5         StringBuffer sb = new StringBuffer("1223");
 6 
 7         // append
 8         sb.append("4567");
 9         System.out.println(sb);    // 12234567
10 
11         // insert
12         sb.insert(1,1);
13         System.out.println(sb);    // 112234567
14 
15         // delete/deleteCharAt
16         sb.delete(3,5);
17         System.out.println(sb);    // 1124567
18         sb.deleteCharAt(2);
19         System.out.println(sb);    // 114567
20 
21         // replace
22         sb.replace(1,3,"6");
23         System.out.println(sb);     // 16567
24 
25         // reverse
26         sb.reverse();
27         System.out.println(sb);  // 76561
28 
29         // setCharAt
30         sb.setCharAt(0,'2');
31         System.out.println(sb);       // 26561
32 
33         // setLength
34         sb.setLength(4);
35         System.out.println(sb);    // 2656
36 
37         // subSequence
38         CharSequence cs = sb.subSequence(0,3);
39         System.out.println(cs);     // 265
40 
41         // subString
42         String str1 = sb.substring(1);
43         String str2 = sb.substring(1,3);
44         System.out.println(str1+" "+ str2);   //656 65
45 
46         // toString
47         String str3 = sb.toString();
48         System.out.println(str3);   // 2656
49         
50     }
51 }

View Code

4. StringBuilder類經常使用方法

 StringBuilder類的方法與StringBuffer相似，這裏再也不贅述。

5. 其餘說明

（1）基本原則：String用於操做少許的數據；StringBuilder用於單線程操做大量數據；StringBuffer用於多線程操做大量數據。

（2）不要使用String類的"+"來進行頻繁的拼接，它會致使性能變差；應使用StringBuffer或StringBuilder類進行這些操做。

（3）爲了得到更好的性能，在構造 StringBuffer 或 StringBuilder 時應儘量指定它們的容量。

!!!!!!!