Java-StringBuffer类

1. StringBuffer类

1.1:StringBuffer类发展源于：

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题 线程安全的可变字符序列

1.2 线程安全：

1、安全，代表着没有同步操作的出现，数据是安全的，但是效率低
2、不安全，代表着有同步操作出现，效率相比较安全情况，会高
3、在IT行业开发中，效率和安全一直都是一个头疼的问题
5、举例生活中有哪些线程安全或者不安全的问题
线程安全：银行相关的业务，医院取号，电影院售票 效率
线程不安全的：视频会员，博客评论，效率高

1.3 何为-public final class StringBuffer

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

++简单记忆：它就是一个线程安全的可变字符串++

(超级重要面试题)String和StringBuffer区别：

1、String长度和内容一旦确定就不能被改变，而StringBuffer长度和内容都是可以发生改变的
2、StringBuffer可以提前给出一个容器，StringBuffer提前给出一个缓冲区，可以进行字符串的拼接，而不会开辟新的空间 String来说每做一次拼接都会开辟新的空间

1.4 StringBuffer类的构造方法

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

++StringBuffer的方法：
public int capacity()返回当前容量。 容量是新插入字符可用的存储量，超过此值将进行分配。
public int length()返回长度（字符数）。++

上代码：

/*
 *  StringBuffer类概述：
 *  我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的对象，既耗时，又浪费空间。
 *  而StringBuffer就可以解决这个问题
 *  线程安全的可变字符序列
 *
 *  线程安全：
 *  1 安全：代表没同步操作的出现。数据是安全的，但是效率低下
 *  2 不安全：代表着有同步操作的出现，效率相对比较高，但是安全性低
 *  4 举例生活中那些线程安全还是不安全的问题
 *          线程安全：银行相关的业务。医院取号，电影院售票 效率低
 *          线程不安全：视屏会员，博客评论， 效率高
 *
 * public final class StringBuffer
 *   线程安全，可变字符序列
 *   字符缓冲区就像一个String，但是可以修改
 *   在任何时间点，它包含了一些特定的字符序列，但是可以通过调用某种方法修改序列的长度可内容
 *
 *   简单记忆：它就是线程安全的可变字符序列
 *
 *   （面试题）：StringBuffer和 String 的区别：
 *   1. String的长度一旦被确定就不能被更改，而StringBuffer长度和内容可以发生改变
 *   2。 String可以提前给出一个容器，StringBuffer提前给出一个缓冲区，可以进行字符串的拼接而不是
 *       开辟新的空间，String每一次的拼接都会开辟空间。
 *
 *    StringBuffer的构造方法：
 *                      1，StringBuffer()
 *                              构造一个没有字符的缓冲区，初始容量为16个字符
 *                      2. StringBuffer(int capacity)
 *                             构造一个没有字符的字符缓冲区和指定的初始容量
 *                      3.StringBuffer（String str）
 *                              构造一个初始化为指定字符串内容的字符缓冲区
 *
 *   StringBuffer的方法：
 *                  public int capacity()返回当前容量，容量是新插入字符的可用存储量超过此值将进行分配
 *                  public int length()返回长度


 */
public class StringBufferDemo1 {
    public static void main(String[] args) {
        //StringBuffer()
        //构造一个没有字符的字符缓冲区，初始容量为16个字符
        StringBuffer sb = new StringBuffer("");
        System.out.println("sb:"+sb.length());//StringBuffer类中重写了Object中的toString方法。否则为地址值
        //我们想要验证初始容量，就得想办法获取这个StringBuffer的容量值
        System.out.println("sb容量为："+sb.capacity());
        System.out.println("sb的实际存储值为："+sb.length());

        System.out.println("===============================================================================");

        //StringBuffer(int capacity)
        StringBuffer sb1 = new StringBuffer(30);
        System.out.println("sb1："+sb1);//StringBuffer重写了Object中的toString（）方法
        //我们想要验证初始容量值，就得想办法获取这个StringBuffer的容量值
        System.out.println("sb1容量为："+sb1.capacity());
        System.out.println("sb1的实际存储值为："+sb1.length());
        System.out.println("==================================================================================");
        //StringBuffer（String str）构造一个初始化为指定字符串内容的字符串缓冲区。
        StringBuffer sb2 = new StringBuffer("hello");
        System.out.println("sb2："+sb2);
        System.out.println("sb2的容量为："+sb2.capacity());
        System.out.println("sb2的实际存储值为："+sb2.length());
    }
}

1.5 添加功能：

• public StringBuffer append(String str)
• public StringBuffer insert(int offset,String str)

添加操作实际上操作的是同一个对象，不管是什么类型的都可以添加。添加进去后会自动专成字符串形式

插入：在下标为 3 的地方插入，原来下标为 3 的往后迁移。

练习代码如下：

/*
        添加功能：
                public StringBuffer append（String str）
                public StringBuffer insert(int offset,String str)
 */
public class StringBufferDemo2 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        System.out.println("sb:"+sb);

        //public StringBuffer append(String str)将指定的字符串附加到此字符序列。
        //实际上操作的是调用方法的StringBuffer对象，返回的也是同一个对象
        StringBuffer sb2 = sb.append("hello");
        System.out.println("sb2:"+sb2);
        System.out.println(sb == sb2);//调用append方法返回的是同一个对象
        System.out.println("===================================================");
        sb.append("hello").append("world").append("nihao").append("java");
        System.out.println(sb);
        System.out.println("======================================================");
        //刚才我们观察API的时候，发现StringBuffer不仅可以添加String类型的数据还可以添加
        //boolean,double,int(byte,short),flot,long,shar.Object;
        sb.append(19.23).append(23).append(23.3f).append('a');
        System.out.println(sb);
        //注意：无论添加什么类型进来，只要存进去都是一个一个字符串
        Demo demo  = new Demo();
        sb.append(demo);
        //传进来的是一个地址值
        System.out.println(sb);//hellohelloworldnihaojava19.232323.3aDemo{name='null', age=0}
        System.out.println("=======================================================");
        //public StringBuffer insert(int offset, String str)将字符串插入到此字符序列中
        // //String参数的String按顺序插入到指定偏移量的该序列中，向上移动原始位于该位置的任何字符，
        // 并将该序列的长度增加到参数的长度
        sb.insert(5,"小朋友").insert(6,"可爱");
        System.out.println(sb);
    }
}

1.6删除功能

• public StringBuffer deleteCharAt(int index)
• public StringBuffer delete(int start,int end)

注意：含头不含尾部，

代码如下：

/*
            删除功能：
                    public StringBuffer deleteCharAt(int index)
                    public StringBuffer deleteCharAt(int start,int end)
 */
public class StringBufferDemo3 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("helloworldjavabigdata");
        System.out.println("sb:"+sb);
        System.out.println("sb的存储空间为："+sb.capacity());
        System.out.println("sb的实际存储个数为："+sb.length());
        //public StringBuffer deleteCharAt(int index)删除char在这个序列中的指定位置。该序列缩短了一个char
        System.out.println("=========================================================");
        //sb.deleteCharAt(60);//超出长度会报异常 StringIndexOutOfBoundsException

//        sb.deleteCharAt(0);
//        System.out.println(sb);
        System.out.println("===========================================================");
        //public StringBuffer delete(int start,int end)子串开始与start结束于end-1；（即含头不含尾）
        sb.delete(4,9);
        System.out.println(sb);
        System.out.println("实际存储的值有："+sb.length());
        //需求：删除hello后面的所有字符；
        System.out.println(sb.delete(9,sb.length()));
        System.out.println("实际存储的值大小为："+sb.length());
    }
}

1.7替换功能

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

含头不含尾

/*
            替换功能：
                 public StringBuffer replace(int start,int end,String str)
 */
public class StringBufferDemo4 {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer();
        sb1.append("你好啊！小朋友。很高兴见到你。");
        System.out.println("sb1"+sb1);
        System.out.println("sb1容量为："+sb1.capacity());
        System.out.println("sb1的值实际长度为："+sb1.length());
        //public StringBuffer replace(int start,int end ,String str)
        //依旧是含头不含尾的
        sb1.replace(0,3,"hello!");
        System.out.println(sb1); //输出：hello!！小朋友。很高兴见到你。含头不含尾，所以输出两个！！
        System.out.println(sb1.length());
        sb1.replace(8,12,"各位大美女们，");
        System.out.println("sb1的值为："+sb1);
        System.out.println("sb1的长度为："+sb1.length());
    }
}

1.8 反转功能

/*
            反转功能：public StringBuffer reverse()
            public StringBuffer reverse()导致该字符序列被序列的相反所代替；

 */
public class StringBufferDemo5 {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer("！亲成我上马");
        sb1.reverse();
        System.out.println(sb1);
    }
}                            

1.9截取功能：

• public String substring(int start)
• public String substring(int start,int end)

注意事项：截取出来的数据是String形式的。必须需要String来接收。

/*
        截取功能：
                public String substring(int start)
                public String substring(int start,int end)
 */
public class StringBufferDemo6 {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer();
        sb1.append("hello,")
                .append("java,")
                .append("我爱学习,")
                .append("学习使我快乐")
                .append("woaiBigData");
        System.out.println(sb1);
        System.out.println(sb1.length());
        String sb2 = sb1.substring(16);
        System.out.println(sb2);
        System.out.println(sb2.length());
        System.out.println("============将StringBuffer中的字符串全部转成String类型的===========");
        String sb3 = sb1.substring(0);
        System.out.println(sb3);
    }
}

知识点一：为啥转换和如何转换

String和StringBuffer的相互转换
A,B
A--B,将A类型转成B类型，目的是为了使用B类型中的功能
B--A,再把B类型转成A类型，目的是可能最终的结果需要A类型，所以再把它转化回来

String——>StringBuffer

• 方式一：通过构造函数将String类型的传入
• 方式二：通过append()方法添加。

StringBuffer——>String

• 方式一：调用toString（）方法------推荐
• 方式二：通过subString()方法截取，用string接收
• 方式三：通过String的构造方法，将StringBuffer传入。

代码：

/*
        String和StringBuffer的相互转换
        A,B
        A——>B：将A转换成B，目的是为了使用B类型中的工能
        B——>A：将B转换成A，目的是最终结果需要A类型
 */
public class StringBufferDemo7 {
    public static void main(String[] args) {
        //String——>StringBuffer
        //String类型与StringBuffer类型没有任何关系，没有继承，属于不同的类，不能直接赋值
        //如：StringBuffer sb = "a";
        String a = "hello";
        //方式一：通过构造方法进行转换
        StringBuffer sb = new StringBuffer(a);
        System.out.println(sb);
        //方式二：使用StringBuffer类中的append()方法；
        StringBuffer sb1 = new StringBuffer();
        sb1.append("我爱我家！");
        System.out.println(sb1);

        // StringBuffer -->String
        StringBuffer s1 = new StringBuffer("hello");
        //方式一：采用StringBuffer中的substring()方法进行截取；
        String  s = s1.substring(0);
        //(最常用的方法) 调用 toString() 方法
        String s2 = s1.toString();
        System.out.println(s2);
        //方式三：使用String的构造方法
        String s3 = new String(s1);


    }
}

知识点二：

        1、String,StringBuffer,StringBuilder的区别
          1、String的内容和长度不可变，而StringBuffer和StringBuilder的长度和内容可变
          2、StringBuffer是线程安全的，数据安全，效率低
            StringBuilder是线程不安全的，数据不安全，效率高

       2、StringBuffer和数组的区别
            1、StringBuffer中只能存放字符串。
                而数组既可以存放基本数据类型元素，也可以存放引用数据类型的元素，但是同一个数组只能存放同一种数据类型。
            2、StringBuffer的长度是可变的，而数组的长度一旦定义就不能改变。
            3、都可以进行下标索引取值。

二者处理速度测试如下：

    public static void main(String[] args) {
        //小测试：看看StringBuffer和StringBuilder速度的快慢
        //String类测试：
//        long start = System.currentTimeMillis();
//        String s = "";
//        for (int i = 0; i < 99999; i++) {
//            s+=i;
//        }
//        System.out.println(s);
//        long end = System.currentTimeMillis();
//        System.out.println("时间为："+(end-start));
        
         速度为：1987

        //StringBuffer速度
        long start = System.currentTimeMillis();
        StringBuffer s1 = new StringBuffer();
        for (int i = 0; i < 99999; i++) {
            s1.append(i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        
        速度为：60

//        StringBuilder s2 = new StringBuilder();
//        long start1 = System.currentTimeMillis();
//        for (int i = 0; i < 99999; i++) {
//            s2.append(i);
//        }
//        long end1 = System.currentTimeMillis();
//        System.out.println(end1-start1);
    }
        速度为：2
}

知识点三：当StringBuffer作为参数传递的时候，谁进行了操作，谁就发生了变化

/*
        String作为参数传递
        StringBuffer作为参数传递

 */
public class StringBufferDemo9 {
    public static void main(String[] args) {
//        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

        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        System.out.println("sb1:" + sb1 + ",sb2:" + sb2); //sb1: hello  ,sb2: world
        change(sb1,sb2);
        System.out.println("sb1:" + sb1 + ",sb2:" + sb2); // sb1: hello  ,sb2: worldworld



    }

    // 当StringBuffer作为参数传递的时候，谁进行了操作，谁就发生了变化
    public static void change(StringBuffer sb1,StringBuffer sb2){
        sb1 = sb2;
        sb2 = sb1.append(sb2);
        System.out.println("sb1:" + sb1 + ",sb2:" + sb2); // sb1: worldworld  ,sb2: worldworld
    }

    public static void change(String s1, String s2) {
        s1 = s2;
        s2 = s1 + s2;
        System.out.println("s1:" + s1 + ",s2:" + s2); //s1: world ,s2:worldworld

    }
}