StringBuffer类：字符串缓冲类（Java字符串3）

StringBuffer的引入

字符串的特点：字符串是常量，它们的值在创建之后不能更改。
字符串的内容一旦发生了变换，那么马上会创建一个新的对象。
注意：字符串的内容不适宜频繁修改，因为一旦修改马上就会创建一个新
对象
如果需要频繁修改字符串的内容，建议使用字符串缓冲类。
字符串缓冲类：其实就是一个存储字符的容器，对字符串进行增删查改非常的方便

/**
 * 字符串缓冲类的引入:
 * 字符串的特点：字符串是常量，它们的值在创建之后不能更改。
 * 字符串的内容一旦发生了变换，那么马上会创建一个新的对象。
 * 注意：字符串的内容不适宜频繁修改，因为一旦修改马上就会创建一个新的对象
 * 如果需要频繁修改字符串的内容，建议使用字符串缓冲类。
 */
public class Demo1 {

    public static void main(String[] args){
        String str1 = "hello";
        String str2 = str1 + " world";
        System.out.println("str1和str2是同一个对象吗？"+(str1 == str2)); //==比较的是内存地址
    }
}

1.构造方法

无参构造方法：
1、StringBuffer（）
笔试题目：使用StringBuffer无参的构造方法创建一个对象时，默认的初试容量是多少？如果长度不够使用了，自动增长多少？
答：StringBuffer底层是依赖了一个字符数组才能存储字符数据的，该字符串数组默认的初始容量是16，如果字符数组的长度不够使用时，自动增加一倍（实际是一倍+2）
2、StringBuffer（int capacity）
构造一个不带字符，但具有指定初始容量的字符串缓冲区

2.容器所具备的行为：

增加：
（1）append（boolean b）：可以添加任意类型的数据到容器中
（2）insert（int offset，boolean b）：指定插入的索引值，插入对应的内容。

public class Demo2 {

    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.append("java");
        sb.append("java");
        sb.append("java");
        sb.append("java");
        sb.append("java");

        System.out.println(sb);
    }
}

package StringBuffer;

public class Demo3 {

    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.append("abc");
        sb.append(true);
        sb.append(3.14f);
        System.out.println("字符串缓冲类的内容是:"+sb);
    }

}

package StringBuffer;

public class Demo4 {
    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.append("abc");

        sb.insert(2,"小明");
        System.out.println("字符串缓冲类的内容:"+sb);
    }
}

删除：
（1）delete（int start，int end）：根据指定的开始与结束的索引值删除对应的内容。（左闭右开区间）
（2）deleteCharAt（int index）：根据指定的索引值删除一个字符。

package StringBuffer;

public class Demo5 {
    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.append("abc");
        sb.insert(2,"小明");
        sb.delete(2, 4); //左闭右开
        System.out.println("字符串缓冲类的内容:"+sb);

        sb.deleteCharAt(1);
        System.out.println("字符串缓冲类的内容:"+sb);

    }

}

查看
（1）indexOf（String str，int fromIndex）：查找指定的字符串第一次出现的索引值，并且指定开始查找的索引值。
（2）capacity（）：查看当前字符数组的长度。查看的是字符数组的容量，不是存入的容量
（3）length（）：存储的字符个数。
（4）charAt（int index）：指定的索引值查找字符。
（5）lastIndexOf（String str）：
（6）toString（）：把字符串缓冲类的内容转成字符串返回。

package StringBuffer;

public class Demo11 {
    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.append("abcjavaabc");
        int index1 = sb.indexOf("abc");
        System.out.println("索引值为:"+index1); //0
        int index2 = sb.indexOf("abc", 3); //从第三个下标开始找，所以返回的是7
        System.out.println("索引值为:"+index2); //7
        System.out.println("字符串缓冲类的内容:"+sb);
    }
}

package StringBuffer;

public class Demo12 {
    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.append("abcjavaabc");
        sb.append("javajava");//此时增加了内容，超出了初始长度，所以增加了一倍加2
        System.out.println("查看字符数组的长度:"+sb.capacity()); // 查看的是字符数组的容量，不是存入的容量
        System.out.println("查看存储的字符串的长度:"+sb.length());
        System.out.println("字符串缓冲类的内容:"+sb);
    }
}

package StringBuffer;

public class Demo13 {
    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.append("abcjavaabc");
        System.out.println("指定的索引值查找字符:"+sb.charAt(3));
    }
}

package StringBuffer;

public class Demo14 {
    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.append("abcjavaabc");
        sb.append("hh");
        String content = sb.toString();//当需要一个字符串的时候作为实际参数传参
        test(content);
        System.out.println(content);
    }

    //此时test方法中需要传入的是字符串类型数据，要想sb的内容传入，需
    //要将字符串缓冲类中的字符转换成字符串，使用到toString方法
    public static void test(String s){

    }
}

修改：
（1）replace（int start，int end，String str）：根据指定的开始与结束索引值替代成指定的内容。
（2）reverse（）：翻转字符串缓冲类的内容。
（3）setCharAt（int index，char ch）：把指定索引值的字符替换成指定的字符。
（4）substring（int start，int end）： 根据指定的索引值截取子串。
（5）ensureCapacity（int minimumCapacity）：指定StringBuffer内部的字符数组长度的。

package StringBuffer;

public class Demo6 {
    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.append("ab小明c");
        sb.replace(2,4, "小狗");
        System.out.println("字符串缓冲类的内容:"+sb);
    }
}

package StringBuffer;

public class Demo7 {
    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.append("ab小明c");
        sb.reverse();
        System.out.println("字符串缓冲类的内容:"+sb);
    }
}

package StringBuffer;

public class Demo8 {
    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.append("ab小明c");
        sb.setCharAt(3, '红');
        System.out.println("字符串缓冲类的内容:"+sb);
    }
}

package StringBuffer;

public class Demo9 {
    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.append("ab小明c");

        String substr = sb.substring(2, 4);
        System.out.println("子串的内容:"+substr);
        System.out.println("字符串的内容:"+sb);
    }


}

package StringBuffer;

public class Demo10 {
    public static void main(String[] args){
        StringBuffer sb = new StringBuffer();
        sb.ensureCapacity(20);
        System.out.println("字符串缓冲类的大小:"+sb.capacity());// 输出34
        /*
        原因：StringBuffer底层是依赖了一个字符数组才能存储字符数据的，该字符串数组默认的初始容量是16，
        如果字符数组的长度不够使用时，自动增加一倍（实际是一倍+2）
         */
    }
}

注意：
String类中含有contains方法，StringBuffer类中不含contains方法。