API（二）— StringBuffer

一、 StringBuffer概述

1. 什么是StringBuffer

​线程安全的可变字符序列。一个类似于 String 的字符串缓冲区。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容 。
​StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。线程安全的可变字符序列。

2. 为什么提供StringBuffer

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

二、 StringBuffer特点

1. StringBuffer特点介绍

StringBuffer是使用缓冲区的，本身也是操作字符串的，但与String类不同，String类中的内容一旦声明之后不可改变，改变的只是其内存地址的指向，而StringBuffer中的内容是可以改变的。

对于StringBuffer而言，本身是一个具体的操作类，所以不能像String那样采用直接赋值的方式进行对象实例化，必须通过构造方法完成。

2. StringBuffer和String区别

1.前者长度内容可变;后者不可变。
2.如果使用前者做字符串的拼接，不会浪费太多的资源。

3. StringBuffer构造方法：

//构造方法有很多，但是我们常用的为以下三个：
//无参构造方法
public StringBuffer()
//指定容量的字符串缓冲区对象(容器的大小)
public StringBuffer(int capacity)
//指定字符串内容的字符串缓冲区对象(字符串)
public StringBuffer(String str)

演示代码如下：

public static void main(String[] args) {
    // public StringBuffer():无参构造方法
    StringBuffer sb = new StringBuffer();
    System.out.println("sb:" + sb);
    System.out.println("sb.capacity():" + sb.capacity());
    System.out.println("sb.length():" + sb.length());
    System.out.println("--------------------------");

    // public StringBuffer(int capacity):指定容量的字符串缓冲区对象
    StringBuffer sb2 = new StringBuffer(50);
    System.out.println("sb2:" + sb2);
    System.out.println("sb2.capacity():" + sb2.capacity());
    System.out.println("sb2.length():" + sb2.length());
    System.out.println("--------------------------");

    // public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
    StringBuffer sb3 = new StringBuffer("hello");
    System.out.println("sb3:" + sb3);
    System.out.println("sb3.capacity():" + sb3.capacity());
    System.out.println("sb3.length():" + sb3.length());
}

三、StringBuffer功能方法

1. 添加功能

//1.可以把任意类型的数据添加到字符串缓冲区里面，并返回字符串缓冲区本身。
//参数：str 拼接的字符串
public StringBuffer append(String str)

//2.在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身。
//参数1：offset 开始位置
//参数2：str 拼接的字符串
public StringBuffer insert(int offset,String str) 

演示代码如下：

public static void main(String[] args) {
    // 创建字符串缓冲区对象
    StringBuffer sb = new StringBuffer();

    // public StringBuffer append(String str)
    // StringBuffer sb2 = sb.append("hello");
    // System.out.println("sb:" + sb);
    // System.out.println("sb2:" + sb2);
    // System.out.println(sb == sb2); // true
    
    // 一步一步的添加数据
    // sb.append("hello");
    // sb.append(true);
    // sb.append(12);
    // sb.append(34.56);
    
    // 链式编程
    sb.append("hello").append(true).append(12).append(34.56);
    System.out.println("sb:" + sb);
    
    // public StringBuffer insert(int offset,String
    // str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
    sb.insert(5, "world");
    System.out.println("sb:" + sb);
}   

2. 删除功能

//1.删除指定位置的字符，并返回本身
//参数：index 删除开始位置
public StringBuffer deleteCharAt(int index)
//2.删除从指定位置开始指定位置结束的内容，并返回本身
//参数1：start 删除开始位置
//参数2：end 删除结束位置
public StringBuffer delete(int start,int end)

演示代码如下：

public static void main(String[] args) {
    // 创建对象
    StringBuffer sb = new StringBuffer();
    
    // 添加功能
    sb.append("hello").append("world").append("java");
    System.out.println("sb:" + sb);

    // 删除指定位置的字符，并返回本身
    // public StringBuffer deleteCharAt(int index)
    // 需求：我要删除e这个字符，肿么办?
    sb.deleteCharAt(1);
    // 需求:我要删除第一个l这个字符，肿么办?
    sb.deleteCharAt(1); 
    
    // 删除从指定位置开始指定位置结束的内容，并返回本身
    // public StringBuffer delete(int start,intend)
    // 需求：我要删除world这个字符串，肿么办?
    sb.delete(5, 10);

    // 需求:我要删除所有的数据
    sb.delete(0, sb.length());
    System.out.println("sb:" + sb);
}     

3. 替换功能

//替换功能 
//参数1：start 开始位置
//参数2：start 结束位置
//参数3：str 替换新的字符串
public StringBuffer replace(int start, int end, String str) 

演示代码如下：

public static void main(String[] args) {
    // 创建字符串缓冲区对象
    StringBuffer sb = new StringBuffer();

    // 添加数据
    sb.append("hello");
    sb.append("world");
    sb.append("java");
    System.out.println("sb:" + sb);

    // public StringBuffer replace(int start,int end,Stringstr):从start开始到end用str替换
    // 需求：我要把world这个数据替换为"节日快乐"
    sb.replace(5, 10, "节日快乐");
    System.out.println("sb:" + sb);
}                                        

4. 反转功能

//反转功能   
public StringBuffer reverse()  

演示代码如下：

public static void main(String[] args) {
        // 创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer();

        // 添加数据
        sb.append("霞青林爱我");
        System.out.println("sb:" + sb);
    
        // public StringBuffer reverse()
        sb.reverse();
        System.out.println("sb:" + sb);
}     

5. 截取功能

//1.截取第几个索引值之后的
//参数：start 开始位置
public String substring(int start)
//2.截取第几个索引和第几个索引之间的
//参数1：start 开始位置
//参数2：start 结束位置
public String substring(int start,int end)  

演示代码如下：

public static void main(String[] args) {
    // 创建字符串缓冲区对象
    StringBuffer sb = new StringBuffer();

    // 添加元素
    sb.append("hello").append("world").append("java");
    System.out.println("sb:" + sb);
    
    // 截取功能
    // public String substring(int start)
    String s = sb.substring(5);
    System.out.println("s:" + s);
    System.out.println("sb:" + sb);
    
    // public String substring(int start,int end)
    String ss = sb.substring(5, 10);
    System.out.println("ss:" + ss);
    System.out.println("sb:" + sb);
}                                                                                

四、StringBuffer和String的转换

1. StringBuffer和String的转换

为什么我们要讲解类之间的转换：

A --> B的转换：我们把A转换为B，其实是为了使用B的功能。
B --> A的转换：我们可能要的结果是A类型，所以还得转回来。

public static void main(String[] args) {
    // String -- StringBuffer
    String name = "hello";
    // 注意：不能把字符串的值直接赋值给StringBuffer
    // StringBuffer sb = "hello";
    // StringBuffer sb = name;
    // 方式1:通过构造方法
    StringBuffer sb = new StringBuffer(name);
    // 方式2：通过append()方法
    StringBuffer sb2 = new StringBuffer();
    sb2.append(name);
    System.out.println("sb:" + sb);
    System.out.println("sb2:" + sb2);
    System.out.println("---------------");

    // StringBuffer -- String
    StringBuffer buffer = new StringBuffer("java");
    // String(StringBuffer buffer)
    // 方式1:通过构造方法
    String str = new String(buffer);
    // 方式2：通过toString()方法
    String str2 = buffer.toString();
    System.out.println("str:" + str);
    System.out.println("str2:" + str2);
}

StringBuffer练习：
1、把数组拼接成一个字符串

public static void main(String[] args) {
    // 定义一个数组
    int[] arr = { 44, 33, 55, 11, 22 };

    // 定义功能
    // 方式1：用String做拼接的方式
    String s1 = arrayToString(arr);
    System.out.println("s1:" + s1);

    // 方式2:用StringBuffer做拼接的方式
    String s2 = arrayToString2(arr);
    System.out.println("s2:" + s2);
}

// 用StringBuffer做拼接的方式
public static String arrayToString2(int[] arr) {
    StringBuffer sb = new StringBuffer();

    sb.append("[");
    for (int x = 0; x < arr.length; x++) {
        if (x == arr.length - 1) {
            sb.append(arr[x]);
        } else {
            sb.append(arr[x]).append(", ");
        }
    }
    sb.append("]");

    return sb.toString();
}

// 用String做拼接的方式
public static String arrayToString(int[] arr) {
    String s = "";

    s += "[";
    for (int x = 0; x < arr.length; x++) {
        if (x == arr.length - 1) {
            s += arr[x];
        } else {
            s += arr[x];
            s += ", ";
        }
    }
    s += "]";

    return s;
}

2、把字符串反转

public static void main(String[] args) {
    // 键盘录入数据
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入数据：");
    String s = sc.nextLine();

    // 方式1：用String做拼接
    String s1 = myReverse(s);
    System.out.println("s1:" + s1);
    // 方式2：用StringBuffer的reverse()功能
    String s2 = myReverse2(s);
    System.out.println("s2:" + s2);
}

// 用StringBuffer的reverse()功能
public static String myReverse2(String s) {
    // StringBuffer sb = new StringBuffer();
    // sb.append(s);

    // StringBuffer sb = new StringBuffer(s);
    // sb.reverse();
    // return sb.toString();

    // 简易版
    return new StringBuffer(s).reverse().toString();
}

// 用String做拼接
public static String myReverse(String s) {
    String result = "";

    char[] chs = s.toCharArray();
    for (int x = chs.length - 1; x >= 0; x--) {
        // char ch = chs[x];
        // result += ch;
        result += chs[x];
    }

    return result;
}

3. 判断一个字符串是否是对称字符串
例如:
"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
分析：
​ 判断一个字符串是否是对称的字符串，我只需要把
第一个和最后一个比较
第二个和倒数第二个比较
...
比较的次数是长度除以2。

代码：

public static void main(String[] args) {
    // 创建键盘录入对象
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个字符串：");
    String s = sc.nextLine();

    // 一个一个的比较
    boolean b = isSame(s);
    System.out.println("b:" + b);
    
    //用字符串缓冲区的反转功能
    boolean b2 = isSame2(s);
    System.out.println("b2:"+b2);
}

public static boolean isSame2(String s) {
    return new StringBuffer(s).reverse().toString().equals(s);
}

public static boolean isSame(String s) {
    // 把字符串转成字符数组
    char[] chs = s.toCharArray();
    for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
        if (chs[start] != chs[end]) {
         return false;
        }
    }
    return true;
}

public static boolean isSame(String s) {
    boolean flag = true;

    // 把字符串转成字符数组
    char[] chs = s.toCharArray();

    for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
        if (chs[start] != chs[end]) {
            flag = false;
            break;
        }
    }
    return flag;
}