Java基础快速入门：StringBuilder详解

本文纲要

1. StringBuilder 概述
2. StringBuilder 构造方法
3. StringBuilder 常用成员方法
   append 添加数据
   reverse 反转内容
   length 获取长度
   toString 转为 String
   链式编程
4. StringBuilder 提高效率的原理
5. String 与 StringBuilder 的相互转换
6. 案例：判断对称字符串
7. 案例：拼接字符串

StringBuilder 概述

StringBuilder 是一个可变的字符串类，可以把它看作一个容器。这个容器可以存放任意数据类型（整数、小数、字符、字符串等），但数据进入容器后都会变成字符串

与不可变的 String 类不同，StringBuilder 的内容可以修改，无需每次拼接都创建新对象

核心作用：提高字符串的操作效率

下面通过一段代码对比 String 和 StringBuilder 进行大量字符串拼接时的耗时情况

public class Demo1StringBuilder {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        // 使用StringBuilder进行50000次拼接 
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 50000; i++) {
            sb.append(i);
        }
        System.out.println(sb);
        long end = System.currentTimeMillis();
        System.out.println("StringBuilder 耗时：" + (end - start) + " 毫秒");
    }
 
    public static void method() {
        long start = System.currentTimeMillis();
        String s = "";
        for (int i = 1; i <= 50000; i++) {
            s += i; // 每次拼接都会创建新的String对象 
        }
        System.out.println(s);
        long end = System.currentTimeMillis();
        System.out.println("String 耗时：" + (end - start) + " 毫秒");
    }
}

运行结果示例：

String 拼接 50000 次耗时约 2900 毫秒  
StringBuilder 拼接 50000 次耗时约 260 毫秒  

由此可见，StringBuilder 在高频拼接场景下效率远超 String

StringBuilder 构造方法

StringBuilder 位于 java.lang 包下，无需导包。常用的构造方法有两个：

• public StringBuilder()：创建空白可变字符串对象
• public StringBuilder(String str)：根据给出的字符串创建可变字符串对象

public class Demo2StringBuilder {
    public static void main(String[] args) {
        // 空参构造：创建空容器 
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1); // 输出空白 
 
        // 带参构造：容器初始化时包含指定内容 
        StringBuilder sb2 = new StringBuilder("abc");
        System.out.println(sb2); // 输出 abc 
    }
}

注意：与 String 类似，直接打印 StringBuilder 对象会输出其内容，而不是内存地址

StringBuilder 常用成员方法

1 ) append：添加数据

append 方法可以接收任意类型参数，将其追加到当前可变字符串末尾，并返回对象本身。

public class Demo3StringBuilder {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("红色");
        System.out.println(sb); // 红色 
        sb.append("蓝色");
        System.out.println(sb); // 红色蓝色 
        sb.append("绿色");
        System.out.println(sb); // 红色蓝色绿色 
    }
}

2 ) 链式编程

因为 append 返回的是对象本身，所以可以连续调用：

StringBuilder sb = new StringBuilder();
sb.append("红色").append("蓝色").append("绿色");
System.out.println(sb); // 红色蓝色绿色 

这种调用方式称为链式编程，能简化代码。

3 ) reverse：反转内容

将 StringBuilder 内的字符序列整体反转，也返回对象本身

sb.append("红色").append("蓝色").append("绿色");
System.out.println("反转前：" + sb);
sb.reverse();
System.out.println("反转后：" + sb); // 色绿 色蓝 色红 

4 ) length：获取长度

返回当前容器内字符的个数。

System.out.println("sb中字符个数：" + sb.length()); // 6 

5 ) toString：转换为 String

将 StringBuilder 对象转换为普通的 String 对象，内容不变，类型改变。

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

StringBuilder 提高效率的原理

1 ) String 拼接的内存开销

每次使用 + 进行字符串拼接，底层都会自动执行以下步骤：

1. 创建一个新的 StringBuilder 对象
2. 调用 append 完成拼接
3. 调用 toString 转换为 String 对象

这意味着每遇到一个加号，堆内存中就会产生两个新对象（一个 StringBuilder，一个 String）。多次拼接会产生大量临时对象，占用内存并增加 GC 压力。

2 ) StringBuilder 的内存优势

使用 StringBuilder 拼接时，所有操作都在同一个对象内部完成，不会不断创建新对象。即使进行十万次拼接，堆中也只有一个 StringBuilder 实例，极大提高了效率。

3 ) String 与 StringBuilder 的区别总结

特性	String	StringBuilder
内容可变性	不可变	可变
拼接效率	低（频繁创建新对象）	高（始终操作同一对象）
适用场景	内容改动少、常量字符串	频繁拼接、修改的动态字符串

String 与 StringBuilder 的相互转换

• 在实际开发中，经常需要将 String 转为 StringBuilder 来使用其便捷方法，反之亦然。
• String → StringBuilder：使用 StringBuilder 的有参构造方法
  • StringBuilder sb = new StringBuilder(str);
• StringBuilder → String：调用 toString() 方法
  • String s = sb.toString();

案例：判断对称字符串

需求：键盘录入一个字符串，判断是否对称（例如 12321 对称，123123 不对称）
思路：将字符串转为 StringBuilder，调 reverse 反转，再转回 String 与原串对比

import java.util.Scanner;
 
public class Test8 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入对称字符串:");
        String s = sc.nextLine();
 
        // String 转为 StringBuilder，调用 reverse 反转 
        StringBuilder sb = new StringBuilder(s);
        sb.reverse();
        // StringBuilder 转回 String 
        String reverseStr = sb.toString();
 
        // 比较原串与反转串 
        if (s.equals(reverseStr)) {
            System.out.println("是对称字符串");
        } else {
            System.out.println("不是对称字符串");
        }
    }
}

注意：比较时必须用 equals 比较两个 String，不能用 StringBuilder 直接与 String 比较，否则类型不一致无法得到正确结果。

案例：拼接数组为字符串

需求：定义一个方法，将 int 数组按格式 [1, 2, 3] 拼接为字符串并返回
思路：利用 StringBuilder 的 append 灵活拼接，最后转换为 String 返回

public class Test9 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        String result = arrayToString(arr);
        System.out.println(result); // 输出 [1, 2, 3]
    }
 
    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]).append("]");
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
        return sb.toString();
    }
}

要点：遍历时判断是否为最后一个元素，以拼接正确的分隔符和右中括号
链式调用 append 使代码更简洁

总结

StringBuilder 是可变字符串类，适合频繁修改字符串的场景
构造方法支持空参和传入初始字符串

append、reverse、length、toString 为核心方法，支持链式编程
其高效根源在于只维护一个对象，避免反复创建临时对象

与 String 的相互转换通过有参构造和 toString() 完成
在实际开发中，遇到频繁拼接、反转等需求，优先考虑 StringBuilder

掌握 StringBuilder 能够帮助我们写出更高效、更简洁的 Java 代码，是 Java 基础中不可或缺的重要一环。