常用类(4-1)：StringBuffer类

常用类(4-1)：StringBuffer类

String：字符串 Buffer：缓冲

在API中查找得到StringBuffer类在java.lang下面，不需要导包

一、StringBuffer类的概述

1、特点

（1）线程安全的
        不安全就是存在同步操作同一数据的行为，效率高
        安全的时候，没有同步操作，效率不高

        在开发中，效率和安全一直都是很难平衡的事情
        生活中有线程安全问题的例子：
            线程安全的例子: 银行的一些业务，医院取号，电影院售票
            线程不安全的例子：视频会员，博客评论

（2）线程安全，可变的字符序列
（3）字符串缓冲区就像一个String ，但可以修改
（4）在任何时间点，它包含一些特定的字符序列，但可以通过某些方法调用来更改序列的长度和内容

特点简单记忆：StringBuffer是一个线程安全的可变字符串

2、StringBuffer与String的区别

（1）StringBuffer的长度和内容都是可以发生改变的，String不可变
（2）String每创建一个新的字符串都会开辟一个新的内存空间
    StringBuffer可以提前给出一个容量，可以进行字符串的拼接，而不会重新开辟

二、StringBuffer类的构造方法

1、StringBuffer()
        构造一个没有字符的字符串缓冲区，初始容量为16个字符
2、StringBuffer(int capacity)
        构造一个没有字符的字符串缓冲区和指定的初始容量（需要传入一个int类型的参数）
3、StringBuffer(String str)
   	构造一个初始化为指定字符串内容的字符串缓冲区（需要传入一个字符串参数）

1、StringBuffer()：构造一个没有字符的字符串缓冲区，初始容量为16个字符

public class StringBufferDemo1 {
    public static void main(String[] args) {
        
       //StringBuffer() 构造一个没有字符的字符串缓冲区，初始容量为16个字符
       //按理说打印出的应该是对象的地址值，如果打印出的字符串，
       //那说明StringBuffer重写了Object中的toString()方法,
       //该方法将地址值转换为了字符串
        
       //创建StringBuffe对象
        StringBuffer sb1 = new StringBuffer();
        System.out.println("sb1:" + sb1);//打印sb1：，能看懂
        
        //public int capacity(),返回当前容量
        //查看StringBuffer的容量
        int capacity = sb1.capacity();
        System.out.println("StringBuffer的容量: " + capacity);
        
        int length = sb1.length();
        System.out.println("StringBuffer中字符串的长度: " + length);
       //capacity相当于一瓶水的容量，length相当于里面水的含量（可变的）
    }
}
        
            执行结果如下：
                        sb1:
                        StringBuffer的容量: 16
                        StringBuffer中字符串的长度: 0

                        Process finished with exit code 0

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

public class StringBufferDemo1 {
 public static void main(String[] args) {
     
  //StringBuffer(int capacity) 构造一个没有字符的字符串缓冲区和指定的初始容量
  //构造一个50的容量
  //创建对象，传入int类型的参数
  StringBuffer sb2 = new StringBuffer(50);
  System.out.println("sb2:" + sb2); //StringBuffer重写的toString()方法
     
  int capacity2 = sb2.capacity();//查看StringBuffer的容量
  System.out.println("StringBuffer2的容量: " + capacity2);
  int length2 = sb2.length(); 
  System.out.println("StringBuffer2中字符串的长度: " + length2);
 }
}
     执行结果如下：
                 sb2:
                 StringBuffer2的容量: 50
                 StringBuffer2中字符串的长度: 0

                 Process finished with exit code 0

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

```java
public class StringBufferDemo1 {
    public static void main(String[] args) {
    	//创建对象，传入一个字符串参数
      StringBuffer sb3 = new StringBuffer("hello");
        System.out.println("sb3:" + sb3);
        
        //查看sb3的容量
        int capacity3 = sb3.capacity();
        System.out.println("StringBuffer3的容量: " + capacity3); // 16+5
        int length3 = sb3.length(); //5
        System.out.println("StringBuffer3中字符串的长度: " + length3);

    }
}
            执行结果如下：
                        sb3:hello
                        StringBuffer3的容量: 21
                        StringBuffer3中字符串的长度: 5

                        Process finished with exit code 0
```

三、StringBuffer类的成员方法（添加、删除、替换、反转功能）

1、添加功能

（1）public StringBuffer append(String str)
//观察API发现，不光可以追加字符串类型，还可以将任意数据类型添加到字符串缓冲区中，
//返回的是字符串缓冲区本身(返回的是添加后的字符串)
    
（2）public StringBuffer insert(int offset,String str)
//将字符串插入到此字符序列中,返回的是字符串缓冲区本身(返回的是添加后的字符串)
//需要传入两个参数

（1）public StringBuffer append(String str)

public class StringBufferDemo2 {
    public static void main(String[] args) {
        //创建一个StringBuffer对象
        StringBuffer sb = new StringBuffer();
        //调取方法sb.append().var回车
        StringBuffer s = sb.append("hello");
        /*
            该方法将字符串类型的数据添加到了字符串缓冲区
            返回的是字符串缓冲区本身hello，所以s==sb
         */
        System.out.println(s);//hello
        System.out.println(sb);//hello
        System.out.println(s==sb);//true

        //还可以添加其他的数据类型进去
        sb.append(10);
        System.out.println(sb);//继续添加字符串10打印出:hello10

        sb.append('a');
        System.out.println(sb);//继续添加字符'a'打印出:hello10a

        sb.append(true);
        System.out.println(sb);//继续添加boolean类型打印出:hello10atrue

        sb.append(12.34);//继续添加double类型
        System.out.println(sb);//hello10atrue12.34

        System.out.println(s); //hello10atrue12.34
        /*
            sb和s都在栈中，new出来的东西都在堆中， 一开始sb指向new出来的东西
            用来接收的StringBuffer s 也在栈里面，指向new出来的东西
            堆里面的东西再怎么添加，地址值不会变，因此sb=s
         */

        //也可以使用链式编程
        sb.append(10).append('a').append(true).append(12.34);
        System.out.println(sb);//hello10atrue12.34

（2）public StringBuffer insert(int offset,String str)

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

        //调取方法（sb.append().var回车）添加内容到缓冲区
        StringBuffer s = sb.append("hello");

        //public StringBuffer insert(int index,String str)
        //将字符串插入到此字符序列中。返回的是字符串缓冲区本身
        //String参数的String按顺序插入到指定偏移量的该序列中，
        //向上移动原始位于该位置的任何字符，并将该序列的长度增加到参数的长
        //如果str是null ，则四个字符"null"被插入到该序列中。
        sb.insert(3,"hadoop");//helhadooplo从索引值为3的位置开始添加
        System.out.println(sb);

        //传参是时候不能直接传入null，不然编译会报错
        // sb.insert(3,null);

        //传null时候,需要加双引号
        sb.insert(3,"null");
        System.out.println();//helnullhadooplo
        
        /*
        或者先定义，再传参
        String i = null;
        sb.insert(3,i);
        System.out.println(sb);//helnullhadooplo
         */
    }
}

2、删除功能

今后开发中，有关删除的单词：remove,move,delete,drop,truncate
删除功能
（1）public StringBuffer deleteCharAt(int index)
//删除char在这个序列中的指定位置的字符(该序列缩短了一个char)
    
（2）public StringBuffer delete(int start,int end)
//删除此序列指定区间内的所有字符(区间左闭右开)

（1）public StringBuffer deleteCharAt(int index)：删除char在这个序列中的指定位置的字符

public class StringBufferDemo3 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("bigdata");
        System.out.println("未删除字符之前："+sb);//bigdata

        //删除索引为3位置的字符
        sb.deleteCharAt(3);
        System.out.println("删除字符之后："+sb);//bigata
        /*
            或者带返回值也行
            StringBuffer sb1 = sb.deleteCharAt(3);
            System.out.println("删除字符之后："+sb1);
         */
        //如果 index为负数或大于或等于 length() ,报错
    }
}

（2）public StringBuffer delete(int start,int end):删除此序列指定区间内的所有字符

public class StringBufferDemo3 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("bigdata");
        System.out.println("未删除字符之前："+sb);
        
        //public StringBuffer delete(int start,int end) 
        //删除此序列的子字符串中的字符
        /*
        子串开始于指定start并延伸到字符索引end - 1 ，区间左闭右开[start,end)
        区间内的字符通通删掉；如果start等于end ，则不作任何更改
        */
        
         //删除索引为2到5区间内的字符
        //2<=索引值<5
        sb.delete(2,5);
        System.out.println(sb);//bita

        //删除索引为2到6区间内的字符
		//sb.delete(2,6);
		//System.out.println(sb);//bia

		//使用目前所学的技术删除所有的字符
		//sb.delete(0,sb.length());
		//System.out.println("删除所有的字符sb: "+sb);输出的是个空，什么也没有
    }
}

3、替换功能

public StringBuffer replace(int start,int end,String str)
//将指定的字符/字符串，替换指定区间的字符/字符串（区间范围：左闭右开）

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

        //往StringBuffer中添加内容
        //使用链式编程
   sb.append("hello").append("world").append("mysql").append("hadoop").append("hive");
        System.out.println(sb);//helloworldmysqlhadoophive

        //public StringBuffer replace(int start,int end,String str)
		//将指定的字符/字符串，替换指定区间的字符/字符串
        //区间范围：左闭右开（含头不含尾）
        sb.replace(5,10,"数加学院真好");
        System.out.println(sb);//hello数加学院真好mysqlhadoophive
    }
}

4、反转功能

public StringBuffer reverse()
导致该字符序列被序列的相反代替;如果序列中包含任何替代对，则将它们视为单个字符进行反向操作

public class StringBufferDemo5 {
    public static void main(String[] args) {
        //创建一个一个StringBuffer对象
        StringBuffer sb = new StringBuffer();
        //添加内容
        sb.append("我爱伟玉李");
        System.out.println("反转前："+sb);

        //调用反转的方法
        StringBuffer reverse = sb.reverse();
        //可以直接调用sb
        System.out.println(sb);//李玉伟爱我
        System.out.println(reverse);//李玉伟爱我
    }
}

5、截取功能

（1）String substring(int start)
//从指定位置截取出来一个字符串输出（指定索引为x位置开始截取，x后面（不包含x）截取出来，然后输出）
//需要用返回值接收
    
（2）String substring(int start, int end)
//从指定区间截取出来一个字符串输出
//需要用返回值接收

（1）String substring(int start)

public class StringBufferDemo6 {
    public static void main(String[] args) {
        //创建一个StringBuffer对象
        StringBuffer sb = new StringBuffer();
        //添加内容
        sb.append("java")
                .append("hadoop")
                .append("hive")
                .append("ETL")
                .append("spark")
                .append("flink");
        System.out.println(sb);//javahadoophiveETLsparkflink

        //调用String substring(int start)方法，需要用返回值接收
        String s1 = sb.substring(4);
        System.out.println("截取出来的字符串是：" + s1);//hadoophiveETLsparkflink
        System.out.println("StringBuffer的内容为：" + sb);//javahadoophiveETLsparkflink
    }
}

（2）String substring(int start, int end)

public class StringBufferDemo6 {
    public static void main(String[] args) {
        //创建一个StringBuffer对象
        StringBuffer sb = new StringBuffer();
        //添加内容
        sb.append("java")
                .append("hadoop")
                .append("hive")
                .append("ETL")
                .append("spark")
                .append("flink");
        System.out.println(sb);//javahadoophiveETLsparkflink

        //String substring(int start, int end) ，需要同返回值接收
        //区间左闭右开
        String s2 = sb.substring(10, 17);
        System.out.println("截取出来的字符串是：" + s2);//hiveETL
        System.out.println("StringBuffer的内容为：" + sb);//javahadoophiveETLsparkflink
    }
}