Java容器---字符容器StringBuffer & StringBuilder

1.字符串对象

（1）定义

---String 字符串常量，是不可改变的量，也就是创建后就不能在修改了；

--- StringBuffer 字符串变量（线程安全），StringBuffer对象的值都是可变的；

---StringBuilder 字符串变量（非线程安全），与StringBuffer类基本相同。

---在性能方面，由于String类的操作是产生新的String对象，而StringBuilder和StringBuffer只是一个字符数组的扩容而已，所以String类的操作要远慢于

StringBuffer和StringBuilder。

---String、StringBuffer、StringBuilder都实现了 CharSequence接口。

（2）使用场景

---使用String类的场景：在字符串不经常变化的场景中可以使用String类，例如常量的声明、少量的变量运算。

---使用StringBuffer类的场景：在频繁进行字符串运算（如拼接、替换、删除等），并且运行在多线程环境中，则可以考虑使用StringBuffer，例如XML解析、HTTP参数解析和封装。

---使用StringBuilder类的场景：在频繁进行字符串运算（如拼接、替换、和删除等），并且运行在单线程的环境中，则可以考虑使用StringBuilder，如SQL语句的拼装、JSON封装等。

（3）性能对比

---经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的GC（Garbage Collection）就会开始工作，那速度是一定会相当慢的；

---使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下；

---在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的。

 String S1 = “This is only a" + “ simple" + “ test";
 StringBuffer Sb = new StringBuilder(“This is only a").append(“ simple").append(“ test");

---在大部分情况下 StringBuffer > String

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。

---在大部分情况下 StringBuilder > StringBuffer

java.lang.StringBuilder一个可变的字符序列是JAVA 5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步，所以使用场景是单线程。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的使用方法基本相同。

2.StringBuffer常用方法

StringBuffer:字符串缓冲区，作为一个字符容器,有以下特点：

特点：(1)长度可以变化。

(2)可以对内容通过指定方法进行修改。

(3)容器对象一般都会具备对容器中的元素进行操作的功能。增删改查。

(4)缓冲区可以存储不同类型的数据。

(5)最终缓冲区存储完的数据都会变成字符串。

常用方法：

(1)存储：StringBuffer append();将指定数据作为参数添加到已有数据结尾。

StringBuffer insert(index, data);在指定位置插入数据。

(2)删除：StringBuffer delete(start,end);删除缓冲区中的数据，包含头不包含尾。

SttringBuffer deleteCharAt(index);删除指定位置的字符。

(3)获取：char charAt(int index);返回此序列中指定索引出的字符。

Int indexOf(String Str);返回第一次出现的指定字符串在该字符串中的索引。

Int lastIndexOf(String str);返回最右边出现的指定字符串在此字符串中的索引。

Int length();获取长度。

String substring (int start,int end);返回一个新的字符串，它包含此字符串序列当前所包含的字符子序列。

(4)修改：StringBuffer replace (int start,int end,string str); 使用给定 String 中的字符替换此序列的子字符串中的字符。

Void setcharAt(int index,char ch);在索引处设置字符串。

(5)反转：StringBuffer reverse();将此字符序列用其反转形式取代。

(6) void getChars (int srcBegin,intSrcEnd,char[] dst,int dstBegin);将缓冲区中指定位置的数据存储到指定字符数组中。

  1 class StringBufferDemo{
  2     public static void main(String[] args){
  3         method_getChars();
  4     }
  5
  6     public static void sop(Object obj){
  7         System.out.println(obj);
  8     }
  9
 10     //StringBuffer的存储：append、insert。
 11     public static void method_add(){
 12         StringBuffer sb = new StringBuffer();      //append从字符串缓冲池尾部开始添加字符。
 13         sb.append("abc").append(true).append(34); //把"abc"、true和34转换成字符串，依次加入字符串缓冲池。
 14         sop("缓冲区中的字符串："+sb);
 15
 16         sb.insert(1,22); //在字符串脚标为1的位置插入22.
 17         sop("insert操作后："+sb);
 18     }
 19
 20     //StringBuffer的删除：delete。
 21     public static void method_del(){
 22         StringBuffer sb = new StringBuffer();
 23         sb.append("abc").append(true).append(34);
 24         sop("缓冲区中的字符串："+sb);
 25
 26         sb.delete(3,7); //删除脚标从3到7的字符，包含3不包含7。
 27         sop("delete操作后："+sb);
 28         sb.delete(0,sb.length()); //清空缓冲区，容器StringBuffer消失了。
 29         sop(sb.length());
 30     }
 31
 32     //StringBuffer的获取：charAt()、indexOf()、substring()。
 33     public static void method_get(){
 34         StringBuffer sb = new StringBuffer();
 35         sb.append("abc").append(true).append(34);
 36         sop("缓冲区中的字符串："+sb);
 37
 38         char arr = sb.charAt(2); //获取脚标为2的字符。
 39         int index = sb.indexOf("34"); //获取字符串"34"的位置
 40         String str = sb.substring(3); //获取从脚标3到末尾的子串
 41         sop("脚标为2的字符：........"+arr);
 42         sop("34的位置：............."+index);
 43         sop("子串：................."+str);
 44     }
 45
 46     //StringBuffer的修改：replace(start,end,str)、setCharAt(index,char)。
 47     public static void method_mo(){
 48         StringBuffer sb = new StringBuffer();
 49         sb.append("abc").append(true).append(34);
 50         sop("缓冲区中的字符串："+sb);
 51
 52         sb.replace(3,7,"false");  //把从3到6的子串替换为"false"
 53         sb.setCharAt(sb.length()-1,'9'); //把最后一个字符替换为'9'
 54         sop("修改后：..............."+sb);
 55     }
 56
 57     //StringBuffer的反转：reverse()。
 58     public static void method_re(){
 59         StringBuffer sb = new StringBuffer();
 60         sb.append("abc").append(true).append(34);
 61         sop("缓冲区中的字符串："+sb);
 62
 63         sb.reverse();
 64         sop("反转后：..............."+sb);
 65     }
 66
 67     //6，getChars(start,end,char[],index)：
 68     public static void method_getChars(){
 69         StringBuilder sb = new StringBuilder();
 70         sb.append("abc").append(true).append(34);
 71         sop("缓冲区中的字符串："+sb);
 72
 73         char[] arr = new char[6];
 74         sb.getChars(3,7,arr,1);  //把从3到6的字符串"true"存到字符数组arr[]中，从数组的脚标1开始存。
 75         for(int x=0; x<arr.length; x++){
 76             sop("arr["+x+"]="+arr[x]+"；");
 77         }
 78     }
 79 }
 80

3.StringBuilder

(1)JDK1.5以后，出现了StringBuilder和StringBuffer用法一样。

(2)StringBuffer是线程同步的，适用于多线程。

(3)StringBuilder是线程不同步的，不安全的，适用于单线程。

(4)建议优先采用StringBuilder.

内容来自传智播客和公众号ImportNew

2018-01-03