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 时应尽可能指定它们的容量。

!!!!!!!