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;

欢迎大家一起说出自己的想法。