25.Java之StringBuffer类和StringBuilder类（基本介绍，String、StringBuffer和StringBuilder的比较）

25.1.StringBuffer基本介绍

java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删，很多方法与String相同，但StringBuffer是可变长度的，是一个容器。

1. StringBuffer 实现了 Serializable，即StringBuffer的对象可以串行化
2. 在父类中 AbstractStringBuilder 有属性 char[] value，不是 final，该 value 数组存放 字符串内容，对字符串进行变化的时候（增加/删除），不用每次都更换地址（即不是每次创建新对象），所以效率高于 String
3. StringBuffer 是一个 final类，不能被继承

25.2.StringBuffer的构造器

1. StringBuffer()：
   构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符

StringBuffer stringBuffer = new StringBuffer();

2. StringBuffer(CharSequence seq)：
   构造一个字符串缓冲区，它包含与指定的 CharSequence 相同的字符
3. StringBuffer(int capacity)：
   构造一个不带字符，但具有指定初始容量的字符串缓冲区。即对 char[] 大小进行指定

StringBuffer stringBuffer = new StringBuffer(100);

4. StringBuffer(String str)：
   构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容，给一个String创建StringBuffer，char[] 大小就是 str.length() + 16

StringBuffer stringBuffer = new StringBuffer("hello");

25.3.String与StringBuffer的比较

1. String保存的是字符串常量，里面的值不能更改，每次String类的更新实际就是更改地址，效率较低
2. StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址，效率较高

StringBuffer 类里的char[] value 指向的地址是在堆中，而不是常量池

25.4.String与StringBuffer的互相转换

• String ----> StringBuffer

String str = "hello tom";
// 方式1 使用构造器
// 注意：返回的才是 StringBuffer对象，对str本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
// 方式2 使用的是append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);

• StringBuffer ----> String

StringBuffer stringBuffer01 = new StringBuffer("hello jack");
// 方式1 使用StringBuffer提供的 toString方法
String s = stringBuffer01.toString();
// 方式2 使用构造器来搞定
String s1 = new String(stringBuffer01);

25.5.StringBuffer的常用方法

StringBuffer s = new StringBuffer("hello");

1. append()：增

s.append("张三丰").append(100).append(true).append(10.5);
System.out.println(s);
// hello张三丰100true10.5

2. delete()：删
   删除索引为 >=start && <end 处的字符

s.delete(5,8);
System.out.println(s);
// hello100true10.5

3. replace()：改
   更改索引为 >=start && <end 处的字符

s.replace(8,12,"false");
System.out.println(s);
// hello100false10.5

4. indexOf()：查
   查找指定的子串在字符串第一次出现的索引，如果找不到返回 -1

int indexOf = s.indexOf("100");
System.out.println(indexOf);
// 5

5. insert()：插
   在索引处插入，原来索引的内容自动后移

s.insert(5,"陈真");
System.out.println(s);
// hello陈真100false10.5

6. length()：长度

System.out.println(s.length());
// 19

25.6.StringBuilder类基本介绍

1. 一个可变的字符序列，也是放在堆中。此类提供一个与 StringBuffer 兼容的API，但不保证同步（StringBuilder 不是线程安全）。该类被设计用于 StringBuffer 的一个简易替换，方法是一样的，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快
2. 在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据
3. StringBuilder 的方法，没有做互斥的处理，即没有 synchronized 关键字，因此在单线程的情况下使用 StringBuilder

25.7.String、StringBuffer和StringBuilder的比较

String	StringBuffer	StringBuilder
不可变字符序列，效率低，但是复用率高	可变字符序列，效率较高（增删），线程安全，多线程使用	可变字符序列，效率最高，线程不安全，单线程使用

String 使用注意说明：
String s = "a"; 创建了一个字符串
s += "b"; 实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串 “ab” 。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象留在内存中，降低效率。如果这样的操作放在循环中，会极大影响程序的性能 ==> 结论：如果对String做大量修改，不要使用String

代码演示：

同时添加字符80000次，比较所花费的时间

long startTime = 0L;
        long endTime = 0L;
        String text1 = "";
        String text2 = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {
            text1 = text1 + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的方法执行时间："+(endTime-startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {
            text2.concat(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的concat方法执行时间："+(endTime-startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间："+(endTime-startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间："+(endTime-startTime));

运行结果：

相差还是很明显的，如果把次数扩大，差距也会越大

结论：

1. 如果字符串存在大量的修改操作，一般使用 StringBuffer 或 StringBuilder
2. 如果字符串存在大量的修改操作，并在单线程的情况，使用 StringBuilder
3. 如果字符串存在大量的修改操作，并在多线程的情况，使用 StringBuffer
4. 如果字符串很少修改，被多个对象引用，使用String，比如配置信息等