java中的常用类--StringBuffer类

StringBuffer的区别：
​ 1、线程安全
​ 不安全的时候：就是存在同步操作同一数据的行为，效率高
​ 安全的时候：没有同步操作，效率不高
​ 在开发中，效率和安全一直都是很难平衡的事情。
​ 生活中有哪些线程安全的例子：
​ 线程安全的例子: 银行的一些业务，医院取号，电影院售票
​ 线程不安全的例子：视频会员，博客评论
​ 2、线程安全，可变的字符序列。
​ 3、字符串缓冲区就像一个String ，但可以修改。
​ 4、在任何时间点，它包含一些特定的字符序列，但可以通过某些方法调用来更改序列的长度和内容。
简单记忆：StringBuffer是一个线程安全的可变字符串
StringBuffer与String的区别：

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

StringBuffer的构造方法：

StringBuffer()
构造一个没有字符的字符串缓冲区，初始容量为16个字符。
StringBuffer(int capacity)
构造一个没有字符的字符串缓冲区和指定的初始容量。
StringBuffer(String str)
构造一个初始化为指定字符串内容的字符串缓冲区。

StringBuffer中的方法：

public int capacity() 返回当前容量
StringBuffer中有重写的toString()方法
注意：在StringBuffer里面加入字符串后，容量在原来默认的16上加所加的长度
  StringBuffer sb3 = new StringBuffer("hello");
​        System.out.println("sb3:" + sb3);
​        int capacity3 = sb3.capacity();
​        System.out.println("StringBuffer3的容量: " + capacity3); // 16+5

StringBuffer:添加功能
public StringBuffer append(String str)
观察API发现，不光可以追加字符串类型，还可以将任意数据类型添加到字符串缓冲区中，返回的是什么呢？返回的是字符串缓冲区本身
public StringBuffer insert(int offset,String str)

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

代表删除的命令：remove,move,delete,drop,truncate

StringBuffer: 删除功能

​        public StringBuffer deleteCharAt(int index)

如果 index为负数或大于或等于 length() ,报错
​ 删除char在这个序列中的指定位置。 该序列缩短了一个char 。

​        public StringBuffer delete(int start,int end)   左闭右开[start,end)

子串开始于指定start并延伸到字符索引end - 1 ，或如果没有这样的字符存在的序列的结束。如果start等于end ，则不作任何更改。
StringBuffer替换功能：

public StringBuffer replace(int start,int end,String str)
用指定的String中的字符替换此序列的子字符串中的String 。
子串开始于指定start并延伸到字符索引end - 1 ，
或如果没有这样的字符存在的序列的结束。

第一子串中的字符被去除，然后指定String被插入在start 。
StringBuffer:反转功能：

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

StringBuffer:截取功能
String substring(int start)
返回一个新的 String ，其中包含此字符序列中当前包含的字符的子序列。
String substring(int start, int end)
返回一个新的 String ，其中包含此序列中当前包含的字符的子序列。

String和StringBuffer的相互转换

A--B,将A转换成B,是为了使用B中特有功能
B--A,再将B转换成A,可能是引用最终的结果需要A类型，所以还得转换回来
public class StringBufferDemo7 {
​    public static void main(String[] args) {
//String ---> StringBuffer
​       String s = "hello";
​        //不兼容的类型: java.lang.String无法转换为java.lang.StringBuffer
//        StringBuffer sb1 = s;
//        StringBuffer sb1 = "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);
//StringBuffer ---> String
​        StringBuffer sb3 = new StringBuffer("bigdata");
**//方式1：使用StringBuffer中的toString()方法**
​        //public String toString()
​        String s1 = sb3.toString();
​        System.out.println(s1);
​        System.out.println(sb3);
**//方式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);
​    }
}

面试题1 ：String,StringBuffer,StringBuilder之间的区别
​ 1、StringBuffer是线程同步安全的，数据安全，效率低
​ StringBuilder不是线程同步安全的，数据不安全，效率高
​ 2、String的内容是不可变的，StringBuffer和StringBuilder是可变的
​ 3、StringBuffer中的方法是由synchronized关键字修饰的。
面试题2：StringBuffer和数组的区别？
​ 它们都可以被看作是一个容器，装一些数据。
​ 但是呢，StringBuffer里面的数据都是一个一个的字符
​ 数组可以存放不同数据类型的数据，但是同一个数组只能存放同一种数据类型的数据

探究String与StringBuffer分别作为方法的参数传递的区别
public class StringBufferDemo11 {
​    public static void main(String[] args) {
//        StringBuffer sb = new StringBuffer();
//        sb.append("hello");
//        System.out.println(sb);
//        StringBuilder sb2 = new StringBuilder();
//        sb2.append("world");
//        System.out.println(sb2);
​        String s1 = "hello";
​        String s2 = "world";
​        System.out.println("s1: " + s1+" ,s2:" + s2); //s1:hello ,s2:world
​        change(s1,s2);
​        System.out.println("s1: " + s1+" ,s2:" + s2); //s1:hello ,s2:world
​        System.out.println("*******************************************");
​        StringBuffer sb1 = new StringBuffer("hello");
​        StringBuffer sb2 = new StringBuffer("world");
​        System.out.println("sb1: " + sb1+" ,sb2:" + sb2);
​        change(sb1,sb2);
​        System.out.println("sb1: " + sb1+" ,sb2:" + sb2);
​        //sb1: hello ,sb2:worldworld
​    }
//StringBuffer作为参数列表
​    private static void change(StringBuffer sb1,StringBuffer sb2){
​        sb1 = sb2;
​        sb2.append(sb1);
​        System.out.println("sb1: " + sb1+" ,sb2:" + sb2);
​        //sb1: worldworld ,sb2:worldworld
​    }
String作为参数列表
​    private static void change(String s12, String s22) {
​        s12 = s22; //s1:"world"
​        s22 = s12 + s22; //s2:"worldworld"
​        System.out.println("s1: " + s12+" ,s2:" + s22);//s1:world ,s2:worldworld
​    }
}

String作为参数列表的图解：

StringBuffer作为参数列表的图解：