StringBuffer的函数使用：append、insert、deleteCharAt、replace、reverse、substring

最新推荐文章于 2024-05-21 00:09:12 发布

原创最新推荐文章于 2024-05-21 00:09:12 发布 · 1k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#Java自学

本文深入探讨了StringBuffer和StringBuilder的特性与区别，包括构造方法、容量与长度、添加、删除、替换、反转、截取等功能，以及如何将数组转换为字符串。同时，对比了两者的线程安全性和效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

StringBuffer与StringBuilder

StringBuffer类概述
我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。
而StringBuffer就可以解决这个问题
线程安全的可变字符序列
StringBuffer类的构造方法
A:StringBuffer的构造方法：
public StringBuffer(): 无参构造方法
public StringBuffer(int capacity): 指定容量的字符串缓冲区对象
public StringBuffer(String str): 指定字符串内容的字符串缓冲区对象

B:StringBuffer的方法：
public int capacity()：返回当前容量。理论值
public int length():返回长度（字符数）。实际值

StringBuffer的添加功能

A:StringBuffer的添加功能
public StringBuffer append(String str): 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

案例一：

public class MyTest {
    public static void main(String[] args) {
        //字符串一旦定义之后，长度是不可变的
        //如果我要采用+号大量拼串，比较浪费空间
        String str = "abc" + "ccc" + "dddd" + "eee";
        //Java为了我们对字符拼接方便的进行操作，给我们提供了一个类StringBuffer这个类，
        //他是一个长度可变的字符容器，可以存储多个字符，可以不断的往容器中追加内容
        //线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。、，但通过某些方法调用可以改变该序列的长度和内容。

        //StringBuffer()
        //构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
        //创建一个字符容器
        StringBuffer sb = new StringBuffer();
        //获取字符容器的容量
        int capacity = sb.capacity();
        System.out.println(capacity);
        //获取长度
        int length = sb.length();
        System.out.println(length);
        System.out.println("----------------------------");
        //容量 和 长度
        // 往容器中追加内容
        StringBuffer sb2 = sb.append(100);  //往容器中追加了一个int类型的数据
        capacity = sb.capacity();
        System.out.println(capacity);
        //获取长度
        length = sb.length();
        System.out.println(length);
        sb2.append("abdefafdasfasdfasdfasdfasdfwfsefesfesfd");

        capacity = sb.capacity();
        System.out.println(capacity);
        //获取长度
        length = sb.length();
        System.out.println(length);
    }
}

案例二：

public class MyTest2 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //追加那个完之后返回的还是原来的容器
        StringBuffer sb2 = sb.append("abc");
        sb2.append(100);
        System.out.println(sb==sb2);
        System.out.println(sb2);

    }
}

案例三：

public class MyTest3 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append(100).append(true).append("abv").append("cccc");
        sb.append(new char[]{'a','c','d'});
        sb.append(new Object());
        //把容器中的内容取出来转成字符
        String string = sb.toString();
        System.out.println(string);


        //StringBuffer(String str)
        //构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

        String string1 = new StringBuffer("abc").append("100").toString();
        System.out.println(string1);
    }
}

public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

案例四：

public class MyTest {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append(100).append(200);
        //在指定的索引处插入内容
        sb.insert(1, "abc");//返回的还是原来的容器

        System.out.println(sb);
    }
}

StringBuffer的删除功能

A:StringBuffer的删除功能
public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身

案例：

public class MyTest2 {
    public static void main(String[] args) {
        //删除相关的方法
        StringBuffer sb = new StringBuffer("abcafeadsfaewfasdf你好啊");
        //根据指定索引删除单个字符，返回的还是容器本身
        sb.deleteCharAt(0);
        sb.delete(0, sb.length());//根据开始索引，和结束索引删除一段数据 含头不含尾 返回的还是容器本身
        System.out.println(sb);

    }
}

StringBuffer的替换和反转功能

A:StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str): 从start开始到end用str替换
B:StringBuffer的反转功能
public StringBuffer reverse(): 字符串反转

案例：

public class MyTest3 {
    public static void main(String[] args) {
        //替换的方法
        StringBuffer sb = new StringBuffer("abc ccc ddd fff");
        //从开始索引，到结束索引，替换成新的内容，返回的还是容器本身
        sb.replace(0, sb.length(), sb.toString().substring(0,sb.indexOf(" ")));
        System.out.println(sb);

    }
}

案例二：

public class MyTest4 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("abcd");
        //反转容器中的内容，返回的还是容器本身
         sb.reverse();
        System.out.println(sb);
    }
}

StringBuffer的截取功能及注意事项

A:StringBuffer的截取功能
public String substring(int start): 从指定位置截取到末尾
public String substring(int start,int end): 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
B:注意事项
注意:返回值类型不再是StringBuffer本身

案例：

public class MyTest5 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("我想要带你去浪漫的土耳其，还要一起去东京和巴黎，其实我喜欢迈阿密");
        //从指定的索引处，截取到末尾，返回值是截取到的字符串
        String s = sb.substring(0);
        System.out.println(s);
        String s1 = sb.substring(0, sb.indexOf("其")+1); //从开始索引截取到结束索引，放回的是截取到的字符串，含头不含尾
        System.out.println(s1);
    }
}

分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列

案例：

public class MyTest {
    public static void main(String[] args) {
        //A:
        //String-- StringBuffer
        String str="abc";
        //方式1
        StringBuffer sb = new StringBuffer(str);
        //方式2
        StringBuffer sb2 = new StringBuffer().append(str);
        StringBuffer sb3 = new StringBuffer().insert(0, str);
        StringBuffer sb4 = sb.replace(0, str.length(), str);



        //StringBuffer----String
        StringBuffer sb5= new StringBuffer("abc");
        //方式1
        String string = sb5.toString();
        //方式2
        String substring = sb5.substring(0);
        //方式3
        //String(StringBuffer buffer)
        //分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。
        String s = new String(sb5);


    }
}

把数组中的数据按照指定个格式拼接成一个字符串

案例：

public class MyTest {
    public static void main(String[] args) {
        //需求：把数组中的数据按照指定个格式拼接成一个字符串
        //举例：
        //int[] arr = {1, 2, 3};
        //输出结果：
        //
        //用StringBuffer的功能实现
        int[] arr = {1, 2, 3};

        //"[1, 2, 3]"
        StringBuffer sb = new StringBuffer("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                sb.append(arr[i]).append("]");
            }else{
                sb.append(arr[i]).append(",");
            }

        }

        String string = sb.toString();
        System.out.println(string);


    }
}

案例二：

import java.util.Scanner;

public class MyTest2 {
    public static void main(String[] args) {
        //A:
        //案例演示
        //需求：把字符串反转
        //举例：键盘录入 "abc"
        //输出结果："cba"
        //用StringBuffer的功能实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.nextLine();
        StringBuffer sb = new StringBuffer(str);
        String string = sb.reverse().toString();
        System.out.println(string);


    }
}

返回第一次出现的指定子字符串在该字符串中的索引

案例：
//int indexOf (String str,int fromIndex)从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。

public class MyTest3 {
    public static void main(String[] args) {
        //int indexOf (String str)返回第一次出现的指定子字符串在该字符串中的索引。
        //
        //int indexOf (String str,int fromIndex)从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
        StringBuffer sb = new StringBuffer("返回第一次出现的指定子字符串在该一符串中的索引");
        int index = sb.indexOf("一",sb.indexOf("一")+1);
        System.out.println(index);


    }
}

StringBuffer和StringBuilder的区别

1.StringBuffer 字符串缓冲区线程安全的效率低
2.StringBuilder 字符串缓冲区线程不安全效率高
3.一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。
该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，
//建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

String和StringBuffer分别作为参数传递

A:形式参数问题
String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递

案例：

public class MyTest {
    public static void main(String[] args) {
        //基本类型作为参数传递，形参的改变，不影响实参
        //引用类型作为参数传递，形参的改变，会影响实参
        //值传递，引用传递

        //String 类型作为参数传递，跟基本类型一样
        String str = "abc";
        setString(str);
        System.out.println(str); //2 "abc"


        StringBuffer sb = new StringBuffer("你好世界");
        setStringBuffer(sb);
        System.out.println(sb.toString());//

    }

    private static void setStringBuffer(StringBuffer sb) {

        sb.append("爱生活，爱Java").reverse();
    }

    private static void setString(String str) {
        str = str + "dddd";
        System.out.println(str); // 1 "abcdddd"
    }
}