StringBuffer的特点：

1、线程安全：不安全，存在同步操作同一数据的行为，效率高。安全的时候，没有同步操作，效率低。

2、StringBuffer是一个可变序列。

3、StringBuffer又被称为字符缓冲区，把它当成一个字符串去操作，只不过它与string相比是可以修改内容的。

4、在任何时间点，它包含着一些特定的字符序列，但是可以通过某些字符序列的长度和内容。

StringBuffer与String的区别：

1、StringBuffer的内容和长度都是可以改变的，String却不可以。

2、String创建每一个字符串都会在常量池开辟一个新的空间。而StringBuffer会提前给出容量，可以重新进行字符串拼接，而不会重新开辟空间。

StringBuffer的构造方法：

public StringBuffer();构造一个没有字符的字符串缓冲区，初始容量为16字符。

public StringBuffer(int capacity);构造一个没有字符的字符串缓冲区和指定的初始容量。

public StringBuffer(String str);构造一个初始化为指定内容的字符串缓冲区。

public static void main(String[] args) {
    // 构造一个没有字符的字符串缓冲区，初始容量为16个字符。
    StringBuffer sb1 = new StringBuffer();
    System.out.println("sb1:" + sb1); // StringBuffer重写了toString方法
    // 如何获取StringBuffer的容量
    // public int capacity()返回当前容量。
    System.out.println("当前StringBuffer的容量为：" + sb1.capacity());
    // public int length()返回长度（字符数）。
    System.out.println("StringBuffer中字符串的长度为：" + sb1.length());

    System.out.println("===================================================");
    // public StringBuffer(int capacity)  构造一个没有字符的字符串缓冲区和指定的初始容量。
    StringBuffer sb2 = new StringBuffer(50);
    System.out.println("sb2:" + sb2); // StringBuffer重写了toString方法
    // 如何获取StringBuffer的容量
    // public int capacity()返回当前容量。
    System.out.println("当前StringBuffer的容量为：" + sb2.capacity());
    // public int length()返回长度（字符数）。
    System.out.println("StringBuffer中字符串的长度为：" + sb2.length());

    System.out.println("===================================================");
    // public StringBuffer(String str) 构造一个初始化为指定字符串内容的字符串缓冲区。
    StringBuffer sb3 = new StringBuffer("hello");
    System.out.println("sb3:" + sb3); // StringBuffer重写了toString方法
    // 如何获取StringBuffer的容量
    // public int capacity()返回当前容量。
    System.out.println("当前StringBuffer的容量为：" + sb3.capacity()); // 21 = 16 + 5
    // public int length()返回长度（字符数）。
    System.out.println("StringBuffer中字符串的长度为：" + sb3.length()); // 5
}

StringBuffer的添加功能：

public StringBuffer append(String str)

通过API发现不仅可以追加字符串，还可以是任意数据类型的数据追加到StringBuffer中；

返回StringBuffer是：public StringBuffer insert(int index,String str)

public static void main(String[] args) {
    // 创建一个StringBuffer对象
    StringBuffer sb = new StringBuffer();

    //public StringBuffer append(String str)
    StringBuffer stringBuffer = sb.append("hello");
    System.out.println(stringBuffer);
    System.out.println(sb);
    System.out.println(sb == stringBuffer);

    // sb.append(10);
    // sb.append('a');
    // sb.append(true);
    // sb.append(12.34);
    // 无论追加的数据是什么类型，一旦进入到StringBuffer中就是成了字符串
    // System.out.println(sb);
    // System.out.println(stringBuffer);

    //链式编程追加
    sb.append(10).append('a').append(true).append(12.34);
    System.out.println(sb);
    System.out.println("===============================================");
    // hello10atrue12.34
    // public StringBuffer insert(int offset,String str)
    // 将字符串插入到此字符序列中。返回的是字符串缓冲区本身
    // String参数的String按顺序插入到指定偏移量的该序列中，向上移动原始位于该位置的任何字符，
    // 并将该序列的长度增加到参数的长度。
    sb.insert(5, "hadoop");
    System.out.println(sb);
    // 如果str是null ，则四个字符"null"被插入到该序列中。
    // sb.insert(5,null);
    Object o = null;
    sb.insert(5, o);
    System.out.println(sb);
}

StringBuffer的删除功能：

public StringBuffer delateCharAt(int index);删除指定索引处的字符，

public StringBuffer delate(int start,int end);

public static void main(String[] args) {
    // 使用带参数的构造方法创建StringBuffer对象
    StringBuffer sb = new StringBuffer("bigdata");
    System.out.println("未做删除操作之前的StringBuffer:" + sb);
    // StringBuffer sb2 = sb.deleteCharAt(3); // 操作的是同一个StringBuffer对象
    // System.out.println(sb);
    // System.out.println(sb2);
    // System.out.println(sb==sb2);
    sb.deleteCharAt(3);
    System.out.println("做删除操作之后的StringBuffer:" + sb);
    // 如果 index为负数或大于或等于length() 。
    // index的值最大可以取到实际存储字符串的长度-1
    // sb.deleteCharAt(30);
    // sb.deleteCharAt(6);

    System.out.println("===============================================");
    // public StringBuffer delete(int start,int end)
    // 删除此序列的子字符串中的字符。
    // 子串开始于指定start并延伸到字符索引end - 1 ，或如果没有这样的字符存在的序列的结束。
    // 如果start等于end ，则不作任何更改。
    // start<=index<end
    // bigata
    // sb.delete(2,5);
    // sb.delete(2,6);
    // sb.delete(2,10);
    // 注意开始位置一定是已经存在的索引，否则报错
    // sb.delete(8,10);
    System.out.println(sb);

    // 需求：删除StringBuffer中的所有字符
    sb.delete(0, sb.length());
    System.out.println("删除StringBuffer中的所有字符：" + sb);

}

StringBuffer的替换功能：

public StringBuffer replace(int start,int end,String str)

用指定的String中的字符替换子字符串中的String

字串开始于指定start并延伸到索引end-1，或如果没有这样的字符存在的序列而结束。第一字串中的的字符被去除，然后指定String被插入在start。

public static void main(String[] args) {
    //创建一个StringBuffer对象
    StringBuffer sb = new StringBuffer();
    //往StringBuffer中添加一些内容
    sb.append("java").append("mysql").append("hadoop").append("hive").append("spark").append("flink");
    System.out.println(sb);
    //public StringBuffer replace(int start,int end,String str)
    sb.replace(5,10,"数加学院真好");
    System.out.println(sb);
}

StringBuffer的反转功能：

public StringBuffer reverse()

导致改字符序列被相反的序列代替。如果字符串包含任何替代对，则将他们是为单个字符进行反向操

public static void main(String[] args) {
    StringBuffer sb = new StringBuffer();
    sb.append("我爱你中国");
    System.out.println("反转之前：" + sb);

    System.out.println("反转之后：");
    StringBuffer sb2 = sb.reverse(); // 操作的是同一个StringBuffer对象
    System.out.println(sb);
    System.out.println(sb2);
}

StringBuffer的截取功能：

public StringBuffer substring(int start)

返回一个新的String,其中包含此序列中当前包含的字符的子序列

public StringBuffer substring(int start,int end)

返回一个新的String，其中包含此序列中当前包含的字符的子序列，字串起始于指定的start,并扩展到索引为end-1;

public static void main(String[] args) {
    StringBuffer sb = new StringBuffer();
    sb.append("java")
        .append("mysql")
        .append("hive")
        .append("ETL")
        .append("spark");
    System.out.println(sb);

    // public String substring(int start)
    // 不会改变原来StringBuffer中的数据
    // 返回值是一个String类型的数据
    String s1 = sb.substring(4);
    System.out.println("截取的内容是："+s1);
    // mysqlhiveETLspark
    System.out.println("StringBuffer的内容为："+sb);
    //StringBuffer的内容为：javamysqlhiveETLspark

    // public String substring(int start,int end) 含头不含尾 [start,end)
    // javamysqlhiveETLspark
    String s2 = sb.substring(9, 13);
    System.out.println("截取的内容是："+s2);
    // 截取的内容是：hive
    System.out.println("StringBuffer的内容为："+sb);
    // StringBuffer的内容为：javamysqlhiveETLspark
}

String与StringBuffer之间的转换:

为什么要进行转换：A—>B,是为了使用B中的特殊功能，B—>A，可能是需要的最终结果是A类型的数据。

 public static void main(String[] args) {
     // String --> StringBuffer
     String s = "hello";
     // StringBuffer sb = s;
     // java: 不兼容的类型: java.lang.String无法转换为java.lang.StringBuffer
     // StringBuffer sb = "hello";
     // 方式1：通过构造方法转换
     StringBuffer sb1 = new StringBuffer(s);
     System.out.println(s);
     System.out.println(sb1);
     //方式2：通过append()
     StringBuffer sb2 = new StringBuffer();
     sb2.append(s);
     System.out.println(s);
     System.out.println(sb2);

     System.out.println("==============================================");
     // StringBuffer --> String
     StringBuffer sb3 = new StringBuffer("bigdata");
     // 方式1：toString()方法
     String s1 = sb3.toString();
     System.out.println(sb3);
     System.out.println(s1);
     //方式2：subString
     String s2 = sb3.substring(0);
     System.out.println(s2);
     System.out.println(sb3);
     // 方式3：String类的构造方法
     // String(StringBuffer buffer)
     // 分配一个新的字符串，其中包含当前包含在字符串缓冲区参数中的字符序列。
     String s3 = new String(sb3);
     System.out.println(s3);
     System.out.println(sb3);
 }

String、StringBuffer和StringBulider之间的区别：

1、StringBuffer是线程同步安全的，数据安全，效率低。Stringbulider不是线程同步安全的，数据不安全，效率高。

2、String的内容是不可改变的，StringBuffer和StringBulider是可变序列。

3、StringBuffer上有synchronized关键字。

StringBuffer和数组之间的区别：

它们都可以看作是一个容器，装一些数据

但是，StringBuffer里面是一个一个字符

数组可以存放不同类型的数据，但StringBuffer只能存放一种数据。

批注：本文博客参照博客