java中的StringBuilder类

于 2021-03-12 15:57:22 发布
阅读量270 收藏
点赞数 1
文章标签： 字符串 java 数据结构 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_42211758/article/details/114698392
版权
本文详细介绍了StringBuilder类的使用方法，包括字符串拼接、反转等操作，并对比了与String类的区别。通过实例演示了如何利用StringBuilder提高字符串操作效率。

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

知识点–2 StringBuilder类

知识点–2.1 String类字符串拼接问题

目标:
  • String类字符串拼接问题
步骤:
  • 字符串拼接问题
讲解:
字符串拼接问题

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。例如：

public class StringDemo {
    public static void main(String[] args) {
        String s = "Hello";
        s += "World";// s = s + "World";
        System.out.println(s);// HelloWorld
        // 在内存中有三个字符串对象,分别是:"Hello"  "World"  "HelloWorld"
    }
}

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。

根据这句话分析我们的代码，其实总共产生了三个字符串，即"Hello"、"World"和"HelloWorld"。引用变量s首先指向Hello对象，最终指向拼接出来的新字符串对象，即HelloWord 。在这里插入图片描述
由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为了解决这一问题，可以使用java.lang.StringBuilder类。

小结
  • 结论:
    • String类的字符串拼接,每一次拼接完都会得到一个新的字符串对象,所以比较耗时,也浪费空间

知识点–2.2 StringBuilder类概述以及与String类的区别

目标
  • 理解StringBuilder的概述和与String类的区别
路径
  • StringBuilder类的概述
  • StringBuilder类和String类的区别
讲解
StringBuilder类概述

​ StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的

StringBuilder类和String类的区别

  • String类：内容是不可变的

  • StringBuilder类：内容是可变的在这里插入图片描述

小结
  • StringBuilder 是一个可变的字符串类,表示字符串
  • StringBuilder 拼接是直接在本身的字符串末尾进行追加的

知识点–2.3 StringBuilder类的构造方法

目标:
  • StringBuilder构造方法
路径:
  • StringBuilder构造方法
讲解:
  • 常用的构造方法
    public StringBuilder()创建一个空白可变字符串对象，不含有任何内容
    public StringBuilder(String   str)根据字符串的内容，来创建可变字符串对象
  • 示例代码
public class Test {
    public static void main(String[] args) {
        /*
            StringBuilder类的构造方法
                    public StringBuilder()创建一个空白可变字符串对象，不含有任何内容
                    public StringBuilder(String   str)根据字符串的内容，来创建可变字符串对象
         */
        // 创建一个空的可变字符串对象
        StringBuilder sb1 = new StringBuilder();
        System.out.println("sb1:"+sb1+"===");// ""
        System.out.println("sb1的字符串长度:"+sb1.length());// 0

        // 根据字符串的内容，来创建可变字符串对象
        StringBuilder sb2 = new StringBuilder("helloword");
        System.out.println("sb2:"+sb2);// helloword
        System.out.println("sb2的字符串长度:"+sb2.length());// 9
    }
}

知识点–2.4 StringBuilder类拼接和反转方法

目标:
  • StringBuilder类拼接和反转方法
路径:
  • StringBuilder类拼接和反转方法
讲解:
  • 添加和反转方法
public StringBuilder append(任意类型) 拼接数据，并返回对象本身
public StringBuilder insert(int offset, 任意类型) 在指定位置插入数据,并返回对象本身
public StringBuilder reverse()  反转字符串,并返回对象本身
  • 拼接数据
public class Test {
    public static void main(String[] args) {
        /*
            StringBuilder类拼接方法:
                public StringBuilder append(任意类型) 拼接数据，并返回对象本身
         */
        // 创建可变的字符串对象
        StringBuilder sb = new StringBuilder("Hello");

        // sb可变字符串拼接数据
        StringBuilder sb1 = sb.append("World");
        System.out.println("sb:"+sb);// HelloWorld
        System.out.println("sb1:"+sb1);// HelloWorld
        System.out.println(sb == sb1);// true

        // sb.append(100);// 拼接整数
        // sb.append(true);// 拼接boolean值
        // sb.append(3.14);// 拼接小数
        // sb.append('a');//  拼接字符
        // 链式编程
        sb.append(100).append(true).append(3.14).append('a');
        System.out.println("拼接后的字符串:"+sb);// HelloWorld100true3.14a
    }
}
  • 插入数据
public class Test {
    public static void main(String[] args) {
        /*
            public StringBuilder insert(int offset, 任意类型) 在指定位置插入数据,并返回对象本身
         */
        // 创建可变的字符串对象
        StringBuilder sb = new StringBuilder("Hello-World");

        // 往sb对象中插入数据
        StringBuilder sb1 = sb.insert(5, "-Hello-java");
        System.out.println("sb:"+sb);// Hello-Hello-java-World
        System.out.println("sb1:"+sb1);// Hello-Hello-java-World
        System.out.println(sb == sb1);// true

        // 插入数据
        sb.insert(6,100).insert(6,3.14).insert(6,true).insert(6,'a');
        System.out.println("sb:"+sb);// Hello-atrue3.14100Hello-java-World
    }
}
  • 反转字符串
public class Test {
    public static void main(String[] args) {
        /*
            StringBuilder类反转的方法:
                public StringBuilder reverse()  反转字符串,并返回对象本身
         */
        // 创建可变的字符串对象
        StringBuilder sb = new StringBuilder("Hello-World");
        // 反转
        StringBuilder sb1 = sb.reverse();
        System.out.println("sb:"+sb);// dlroW-olleH
        System.out.println("sb1:"+sb1);// dlroW-olleH
        System.out.println(sb == sb1);// true
    }
}
小结
StringBuilder类常用方法:
    public StringBuilder   append(任意类型)  添加数据，并返回对象本身
    public StringBuilder   reverse()  返回相反的字符序列
    public StringBuilder insert(int offset, 任意类型) 在指定位置插入数据,并返回对象本身

知识点–2.5 StringBuilder和String相互转换

目标:
  • StringBuilder和String相互转换
路径:
  • StringBuilder转换为String
  • String转换为StringBuilder
讲解:
String转换为StringBuilder

​ public StringBuilder(String s)：通过StringBuilder的构造方法就可以实现把 String 转换为 StringBuilder

StringBuilder转换为String

​ public String toString()：通过StringBuilder类中的 toString() 就可以实现把 StringBuilder 转换为 String

  • 示例代码
public class Test {
    public static void main(String[] args) {
        /*
             StringBuilder和String相互转换:
                String--->StringBuilder:  public StringBuilder(String str);
                StringBuilder--->String:  public String toString();
         */
        // String--->StringBuilder
        String str = "Hello-World";
        StringBuilder sb = new StringBuilder(str);// sb: "Hello-World"

        // StringBuilder--->String
        String s = sb.toString();// s: "Hello-World"
        System.out.println("s:"+s);
        System.out.println("sb:"+sb);
    }
}
小结
StringBuilder:
	public StringBuilder(String str);  String--->StringBuilder
    public String toString();    StringBuilder--->String

实操–2.6 字符串拼接升级版案例

需求

​ 定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，

​ 并在控制台输出结果。例如，数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]

分析
  1. 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
  2. 定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。返回值类型 String，参数列表 int[] arr
  3. 在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
  4. 调用方法，用一个变量接收结果
  5. 输出结果
实现
public class Test {
    public static void main(String[] args) {
        /*
            需求
                定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
                并在控制台输出结果。例如，数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
         */
        int[] arr = {1,2,3};
        System.out.println(concat(arr));
    }

    /**
     * 按照指定格式拼接数组元素
     *
     * @param arr
     * @return 拼接后的字符串
     */
    public static String concat(int[] arr) {
        // 1.创建一个空的可变字符串对象
        StringBuilder sb = new StringBuilder();

        // 2.循环遍历arr数组中的元素
        for (int i = 0; i < arr.length; i++) {
            // 3.在循环中,获取数组元素
            int e = arr[i];
            // 4.在循环中,判断遍历出来的元素
            if (i == 0) {
                // 4.如果遍历出来的元素是第一个元素,拼接的格式为: [+元素+逗号空格
                sb.append("[").append(e).append(", ");
            } else if (i == arr.length - 1) {
                // 4.如果遍历出来的元素是最后一个元素,拼接的格式为: 元素+]
                sb.append(e).append("]");
            } else {
                // 4.如果遍历出来的元素是中间元素,拼接的格式为: 元素+逗号空格
                sb.append(e).append(", ");
            }
        }
        // 5.返回字符串
        return sb.toString();
    }
}

实操–2.7 字符串反转升级版案例

需求

​ 定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果

​ 例如，键盘录入abc，输出结果 cba

分析
  1. 键盘录入一个字符串，用 Scanner 实现
  2. 定义一个方法，实现字符串反转。返回值类型 String，参数 String s
  3. 在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
  4. 调用方法，用一个变量接收结果
  5. 输出结果
实现
public class Test {
    public static void main(String[] args) {
        /*
            需求
            	定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
            	例如，键盘录入abc，输出结果 cba
         */
        // 键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String str = sc.next();

        // 调用reverse反转方法
        // 打印输出
        System.out.println(reverse(str));
    }

    public static String reverse(String str){
        // 1.创建一个可变的字符串,字符串中的内容和参数str一样
        //StringBuilder sb = new StringBuilder(str);

        // 2.调用可变字符串的reverse方法
        //sb.reverse();

        // 3.返回
        //return sb.toString();

        // 链式编程
        return new StringBuilder(str).reverse().toString();
    }
}
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值