Java 字符串高效处理:StringBuilder、StringBuffer、StringJoiner

目录

[一、String、StringBuilder、StringBuffer 与 StringJoiner](#一、String、StringBuilder、StringBuffer 与 StringJoiner)

[1. 四种类型的区别](#1. 四种类型的区别)

二、StringBuilder:可变字符串

[1. 为什么需要 StringBuilder?](#1. 为什么需要 StringBuilder?)

[2. 常用构造方法](#2. 常用构造方法)

[3. 常用 API](#3. 常用 API)

append():追加内容

insert():插入内容

delete():删除内容

replace():替换内容

reverse():反转字符串

[4. StringBuilder 转换为 String](#4. StringBuilder 转换为 String)

[三、StringBuilder 的底层原理与扩容机制](#三、StringBuilder 的底层原理与扩容机制)

[1. 为什么 StringBuilder 可以修改字符串?](#1. 为什么 StringBuilder 可以修改字符串?)

[2. 默认容量](#2. 默认容量)

[3. 扩容机制](#3. 扩容机制)

[4. 为什么频繁扩容会影响性能?](#4. 为什么频繁扩容会影响性能?)

[5. JDK 版本差异](#5. JDK 版本差异)

[四、StringBuilder 的几个重要注意事项](#四、StringBuilder 的几个重要注意事项)

[1. StringBuilder 没有重写 equals()](#1. StringBuilder 没有重写 equals())

[2. StringBuilder 可以复用](#2. StringBuilder 可以复用)

[3. append(null) 的行为](#3. append(null) 的行为)

五、StringBuffer:线程安全的可变字符串

[1. 与 StringBuilder 的核心区别](#1. 与 StringBuilder 的核心区别)

[2. 为什么一般优先使用 StringBuilder?](#2. 为什么一般优先使用 StringBuilder?)

[3. StringBuffer 是绝对线程安全的吗?](#3. StringBuffer 是绝对线程安全的吗?)

六、StringJoiner:字符串连接工具

[1. 基本使用](#1. 基本使用)

[2. 指定前缀和后缀](#2. 指定前缀和后缀)

[3. 空集合的处理](#3. 空集合的处理)

[4. String.join()](#4. String.join())

[5. 与 Stream 结合](#5. 与 Stream 结合)

七、字符串拼接的性能分析

[1. String 的 + 不一定慢](#1. String 的 + 不一定慢)

[2. 循环中反复拼接](#2. 循环中反复拼接)

[3. 三种拼接工具如何选择?](#3. 三种拼接工具如何选择?)

[八、Java 后端常见实战场景](#八、Java 后端常见实战场景)

案例一:手机号脱敏

案例二:动态构建日志信息

案例三:集合数据格式化

案例四:反转字符串

[案例五:拼接 SQL 的注意事项](#案例五:拼接 SQL 的注意事项)

九、核心知识点

[Q1:StringBuilder 和 String 有什么区别?](#Q1:StringBuilder 和 String 有什么区别?)

[Q2:StringBuilder 和 StringBuffer 有什么区别?](#Q2:StringBuilder 和 StringBuffer 有什么区别?)

[Q3:StringBuilder 默认容量是多少?](#Q3:StringBuilder 默认容量是多少?)

[Q4:StringBuilder 为什么比循环使用 String + 通常更高效?](#Q4:StringBuilder 为什么比循环使用 String + 通常更高效?)

[Q5:StringBuilder 的 equals() 比较内容吗?](#Q5:StringBuilder 的 equals() 比较内容吗?)

[Q6:StringJoiner 和 StringBuilder 有什么区别?](#Q6:StringJoiner 和 StringBuilder 有什么区别?)

[Q7:StringBuilder 是不是线程不安全,所以后端不能使用?](#Q7:StringBuilder 是不是线程不安全,所以后端不能使用?)

[Q8:StringBuilder.toString() 后修改 Builder,会影响之前的 String 吗?](#Q8:StringBuilder.toString() 后修改 Builder,会影响之前的 String 吗?)

[十、Java 与 JavaScript 对比](#十、Java 与 JavaScript 对比)

十一、总结

最终记忆

参考资料


本文系统整理 Java 中三种重要的字符串处理工具:StringBuilder、StringBuffer 和 StringJoiner,重点记录可变字符串机制、常用 API、容量扩展、线程安全、字符串拼接性能及实际业务场景。

一、String、StringBuilder、StringBuffer 与 StringJoiner

Java 中 String 对象不可变。当我们需要频繁修改字符串内容时,可以考虑使用可变字符串处理工具。

1. 四种类型的区别

类型 特点 线程安全 适用场景
String 字符串不可变 对象内容不可变 普通字符串存储和操作
StringBuilder 字符序列可变 不保证 单线程或局部字符串拼接
StringBuffer 字符序列可变,方法提供同步保障 单次操作有同步保障 需要共享可变字符序列的场景
StringJoiner 按分隔符拼接字符串 不保证 集合、列表、格式化输出

核心区别:

  • String:适合普通字符串操作。

  • StringBuilder:适合频繁追加、删除、修改字符串。

  • StringBuffer:提供同步机制的可变字符串类。

  • StringJoiner:专门处理分隔符、前缀和后缀。

对于大多数普通 Java 后端业务,优先掌握 StringBuilder 和 StringJoiner。


二、StringBuilder:可变字符串

StringBuilder 是 Java 提供的可变字符序列类。

1. 为什么需要 StringBuilder?

先看普通的 String 拼接:

java 复制代码
String str = "Hello";

str = str + " Java";
str = str + " Backend";

System.out.println(str);
// Hello Java Backend

由于 String 不可变,拼接操作不会修改原来的 String 对象,而是产生新的字符串结果。

如果在循环中不断拼接:

java 复制代码
String str = "";

for (int i = 0; i < 10000; i++) {
    str += i;
}

这种写法可能产生大量临时字符串处理开销,尤其是随着结果越来越长,重复拼接的成本可能持续增加。

解决方式:使用 StringBuilder。

java 复制代码
StringBuilder sb = new StringBuilder();

for (int i = 0; i < 10000; i++) {
    sb.append(i);
}

String result = sb.toString();

StringBuilder 可以在同一个可变对象中累积字符内容,避免每次追加都必须创建新的 String 结果。

2. 常用构造方法

java 复制代码
// 创建空 StringBuilder
StringBuilder sb1 = new StringBuilder();

// 指定初始容量
StringBuilder sb2 = new StringBuilder(100);

// 根据已有字符串创建
StringBuilder sb3 = new StringBuilder("Java");

需要注意:

java 复制代码
StringBuilder sb = new StringBuilder(100);

System.out.println(sb.length());   // 0
System.out.println(sb.capacity()); // 100

length 与 capacity 的区别:

  • length():当前字符序列的长度。

  • capacity():当前内部缓冲区能够容纳的字符容量。

指定容量 100,并不代表字符串已经拥有 100 个字符。

3. 常用 API

方法 作用
append() 末尾追加内容
insert() 指定位置插入内容
delete() 删除指定范围
deleteCharAt() 删除指定位置字符
replace() 替换指定范围
reverse() 反转字符序列
setCharAt() 修改指定位置的 char
length() 获取当前长度
capacity() 获取当前容量
setLength() 设置字符序列长度
toString() 转换为 String
append():追加内容
java 复制代码
StringBuilder sb = new StringBuilder();

sb.append("Java");
sb.append(" ");
sb.append("Backend");

System.out.println(sb); // Java Backend

StringBuilder 支持链式调用:

java 复制代码
StringBuilder sb = new StringBuilder();

sb.append("Java")
  .append(" ")
  .append("Backend")
  .append(" ")
  .append(2026);

System.out.println(sb);
// Java Backend 2026

因为 append() 返回的是当前 StringBuilder 对象。

insert():插入内容
java 复制代码
StringBuilder sb = new StringBuilder("JavaBackend");

sb.insert(4, " ");

System.out.println(sb);
// Java Backend
delete():删除内容
java 复制代码
StringBuilder sb = new StringBuilder("Hello Java");

sb.delete(5, 10);

System.out.println(sb);
// Hello

注意:delete(start, end) 是左闭右开区间,即 [start, end)。

replace():替换内容
java 复制代码
StringBuilder sb = new StringBuilder("Hello Java");

sb.replace(6, 10, "Python");

System.out.println(sb);
// Hello Python
reverse():反转字符串
java 复制代码
StringBuilder sb = new StringBuilder("abcde");

sb.reverse();

System.out.println(sb);
// edcba

这也是 Java 实现字符串反转的一种简洁方式。

注意,对于包含复杂 Unicode 组合字符的文本,reverse() 不一定能够实现符合用户视觉预期的字符反转。

4. StringBuilder 转换为 String

java 复制代码
StringBuilder sb = new StringBuilder("Java");

String str = sb.toString();

sb.append(" Backend");

System.out.println(sb);
// Java Backend

System.out.println(str);
// Java

重要结论:

toString() 返回的是 String 对象。

即使后续修改 StringBuilder,也不会改变已经生成的 String 内容。


三、StringBuilder 的底层原理与扩容机制

1. 为什么 StringBuilder 可以修改字符串?

StringBuilder 内部维护可扩展的字符存储空间。

当调用:

java 复制代码
StringBuilder sb = new StringBuilder();

sb.append("abc");
sb.append("def");

它会将新增字符放入内部存储区域。

逻辑示意:

java 复制代码
初始容量:16

[ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]

append("abc")

[a][b][c][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]

append("def")

[a][b][c][d][e][f][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]

只要剩余容量足够,就可以继续利用已有缓冲区。

如果容量不够,就需要扩容。

2. 默认容量

java 复制代码
StringBuilder sb = new StringBuilder();

System.out.println(sb.capacity()); // 16

默认构造的 StringBuilder 初始容量为 16 个 UTF-16 编码单元。

3. 扩容机制

在常见的 JDK 17 HotSpot 实现中,扩容时可以近似理解为:

java 复制代码
新容量 = max(旧容量 × 2 + 2, 实际所需容量)

例如:

java 复制代码
StringBuilder sb = new StringBuilder(4);

System.out.println(sb.capacity()); // 4

sb.append("12345");

System.out.println(sb.capacity()); // 通常为 10

原因:

原容量为 4,追加 5 个字符时容量不足。

按照上述扩容策略:

java 复制代码
4 × 2 + 2 = 10

于是扩容至 10。

注意:该扩容公式属于 JDK 实现细节,不应当作为所有 Java 实现都必须遵循的 API 保证。

4. 为什么频繁扩容会影响性能?

扩容通常需要申请更大的内部存储空间,并复制已有内容。

如果追加大量已知规模的数据,可以提前指定容量:

java 复制代码
StringBuilder sb = new StringBuilder(10000);

或者:

java 复制代码
sb.ensureCapacity(10000);

这样可以减少扩容次数。

但没有必要在普通业务中盲目指定很大的容量,否则可能浪费内存。

5. JDK 版本差异

Java 8 和 Java 17 在内部字符存储上存在差异:

  • JDK 8:相关实现主要使用 char[]。

  • JDK 9+:HotSpot 引入紧凑字符串相关机制,内部可以通过 byte[] 和编码标记存储内容。

因此,不能简单将 StringBuilder 的容量理解为实际占用了多少字节。

容量是字符序列的逻辑容量,不等于实际内存字节数。


四、StringBuilder 的几个重要注意事项

1. StringBuilder 没有重写 equals()

java 复制代码
StringBuilder a = new StringBuilder("Java");
StringBuilder b = new StringBuilder("Java");

System.out.println(a == b);      // false
System.out.println(a.equals(b)); // false

这是容易出错的地方。

虽然两个 StringBuilder 的内容相同,但是 StringBuilder 没有重写 Object 的 equals() 方法。

因此,默认仍然比较对象身份。

如果需要比较内容:

java 复制代码
System.out.println(
    a.toString().equals(b.toString())
); // true

也可以使用:

java 复制代码
System.out.println(
    a.toString().contentEquals(b)
); // true

2. StringBuilder 可以复用

java 复制代码
StringBuilder sb = new StringBuilder();

sb.append("Java");
System.out.println(sb); // Java

sb.setLength(0);

sb.append("Python");
System.out.println(sb); // Python

setLength(0) 可以清空当前字符序列。

但是:

清空内容并不意味着一定释放已有的内部容量。

如果 StringBuilder 曾经扩容到很大,清空后仍可能保留较大的缓冲空间。

3. append(null) 的行为

复制代码
StringBuilder sb = new StringBuilder();

String name = null;

sb.append(name);

System.out.println(sb);
// null

这里输出的是文本 "null",而不是抛出空指针异常。

这是 StringBuilder 的一个特殊处理行为,不代表所有传入 null 的方法都不会抛异常。

实际开发中,如果不希望输出 "null",可以显式处理:

java 复制代码
sb.append(name == null ? "" : name);

五、StringBuffer:线程安全的可变字符串

StringBuffer 与 StringBuilder 的 API 非常相似。

java 复制代码
StringBuffer sb = new StringBuffer();

sb.append("Java");
sb.append(" Backend");

System.out.println(sb);
// Java Backend

1. 与 StringBuilder 的核心区别

StringBuffer 的部分核心方法使用同步机制保护。

例如,在 JDK 17 的实现中,append() 等操作提供同步保障。

可以近似理解为:

java 复制代码
public synchronized StringBuffer append(String str) {
    // 追加字符串
    return this;
}

上面只是原理示意,并非完整的 JDK 源码。

synchronized 能够对相关操作进行同步控制。

2. 为什么一般优先使用 StringBuilder?

因为 StringBuilder 不需要为自身操作提供同步保障。

在没有共享并发访问的情况下,通常可以避免相关同步开销。

因此:

  • 普通字符串处理:优先 StringBuilder。

  • 确实需要多个线程共同操作同一个可变字符序列:考虑 StringBuffer 或其他同步方案。

3. StringBuffer 是绝对线程安全的吗?

需要区分单次方法调用与多个操作组成的业务逻辑。

java 复制代码
if (buffer.length() > 0) {
    buffer.deleteCharAt(0);
}

即使 buffer 是 StringBuffer,也不能保证整个判断和删除过程具有原子性。

因为另一个线程可能在两次方法调用之间修改内容。

结论:StringBuffer 的方法同步,不等于所有复合业务操作自动具有线程安全性。

另外,如果 StringBuilder 只是方法内部的局部变量,没有在线程之间共享,通常也不存在并发修改问题。


六、StringJoiner:字符串连接工具

StringJoiner 是 Java 8 引入的字符串连接工具类。

它主要解决:

将多个字符串按照指定分隔符连接,并支持统一前缀与后缀。

1. 基本使用

java 复制代码
import java.util.StringJoiner;

StringJoiner sj = new StringJoiner(",");

sj.add("Java");
sj.add("Python");
sj.add("Vue");

System.out.println(sj);
// Java,Python,Vue

相比 StringBuilder,StringJoiner 能够自动处理中间的分隔符。

2. 指定前缀和后缀

java 复制代码
StringJoiner sj = new StringJoiner(",", "[", "]");

sj.add("Java");
sj.add("Python");
sj.add("Vue");

System.out.println(sj);
// [Java,Python,Vue]

构造方法:

java 复制代码
new StringJoiner(分隔符, 前缀, 后缀);

3. 空集合的处理

java 复制代码
StringJoiner sj = new StringJoiner(",", "[", "]");

System.out.println(sj);
// []

可以设置空值表现:

java 复制代码
sj.setEmptyValue("暂无数据");

System.out.println(sj);
// 暂无数据

注意:setEmptyValue() 只影响尚未添加元素时的结果。

4. String.join()

如果不需要逐个追加元素,可以直接使用 String.join()。

java 复制代码
String result = String.join(
    ",",
    "Java",
    "Python",
    "Vue"
);

System.out.println(result);
// Java,Python,Vue

也可以连接集合:

java 复制代码
import java.util.List;

List<String> list = List.of("Java", "Python", "Vue");

String result = String.join(",", list);

5. 与 Stream 结合

后端开发中经常需要将集合处理后连接成字符串。

java 复制代码
import java.util.List;
import java.util.stream.Collectors;

List<String> names = List.of("Tom", "Jack", "Lucy");

String result = names.stream()
        .map(String::toUpperCase)
        .collect(Collectors.joining(","));

System.out.println(result);
// TOM,JACK,LUCY

还可以指定前缀和后缀:

java 复制代码
String result = names.stream()
        .collect(Collectors.joining(",", "[", "]"));

System.out.println(result);
// [Tom,Jack,Lucy]

实际开发选择:

  • 已有集合,直接连接:String.join()。

  • 需要先筛选、转换,再连接:Collectors.joining()。

  • 需要逐个添加、控制分隔符和格式:StringJoiner。

对于前端开发者,可以将它与 JavaScript 的 Array.join() 类比理解。


七、字符串拼接的性能分析

1. String 的 + 不一定慢

java 复制代码
String name = "Tom";

String message = "Hello " + name;

这种简单拼接完全没有必要刻意替换为 StringBuilder。

因为现代 Java 编译器和 JVM 已经对字符串拼接进行了大量优化。

JDK 9 及之后,常见字符串拼接可以借助 invokedynamic 和 StringConcatFactory 实现。

因此:

不能简单地说所有 String 的 + 都比 StringBuilder 慢。

2. 循环中反复拼接

需要注意的是下面这种情况:

java 复制代码
String result = "";

for (int i = 0; i < 10000; i++) {
    result += i;
}

每轮循环都依赖上一轮已经累积的字符串。

随着字符串增长,反复构造新结果可能带来较大的开销。

推荐:

java 复制代码
StringBuilder sb = new StringBuilder();

for (int i = 0; i < 10000; i++) {
    sb.append(i);
}

String result = sb.toString();

3. 三种拼接工具如何选择?

使用场景 推荐
少量字符串拼接 String +
循环累计字符串 StringBuilder
多线程共享字符缓冲区 StringBuffer 或适当同步方案
集合元素按分隔符连接 String.join / StringJoiner
Stream 处理后连接 Collectors.joining

性能差异取决于数据量、JDK 版本、JIT 优化及实际运行环境。

如果要做严谨的性能测试,建议使用 JMH,而不是仅根据一次 System.currentTimeMillis() 的结果判断。


八、Java 后端常见实战场景

案例一:手机号脱敏

假设需要将手机号:

java 复制代码
13812345678

转换成:

java 复制代码
138****5678

可以使用 String 的 substring:

java 复制代码
public static String maskPhone(String phone) {
    if (phone == null || phone.length() != 11) {
        return phone;
    }

    return phone.substring(0, 3)
            + "****"
            + phone.substring(7);
}

也可以使用 StringBuilder:

java 复制代码
public static String maskPhone(String phone) {
    if (phone == null || phone.length() != 11) {
        return phone;
    }

    StringBuilder sb = new StringBuilder(phone);

    sb.replace(3, 7, "****");

    return sb.toString();
}

注意:这里只演示字符串脱敏,手机号是否有效还需要单独验证。

案例二:动态构建日志信息

java 复制代码
StringBuilder sb = new StringBuilder();

sb.append("userId=").append(1001)
  .append(", status=").append("success")
  .append(", duration=").append(125)
  .append("ms");

System.out.println(sb);

输出:

java 复制代码
userId=1001, status=success, duration=125ms

不过,在实际 Spring Boot 项目中,如果使用 SLF4J 日志框架,通常更推荐参数化日志:

java 复制代码
log.info(
    "userId={}, status={}, duration={}ms",
    userId, status, duration
);

这种写法便于统一管理日志,并避免在不需要输出该日志级别时提前进行不必要的字符串拼接。

案例三:集合数据格式化

假设数据库查询返回用户名称:

java 复制代码
List<String> names = List.of(
    "Tom",
    "Jack",
    "Lucy"
);

希望输出:

java 复制代码
用户列表:[Tom, Jack, Lucy]

可以使用:

java 复制代码
String result = names.stream()
        .collect(Collectors.joining(", ", "[", "]"));

System.out.println("用户列表:" + result);

这类代码非常适合用于生成可读的文本摘要。

但是对于真正的 JSON 接口响应,应该使用 Jackson 等 JSON 序列化工具,而不是手动拼接 JSON 字符串。

案例四:反转字符串

java 复制代码
public static String reverse(String text) {
    if (text == null) {
        return null;
    }

    return new StringBuilder(text)
            .reverse()
            .toString();
}

使用:

java 复制代码
System.out.println(reverse("Java"));
// avaJ

这种做法适合简单字符串反转。

如果需要处理复杂 Unicode 文本,并保持用户感知字符的完整性,则需要更专业的字符分割方案。

案例五:拼接 SQL 的注意事项

StringBuilder 也可以用于构建字符串形式的 SQL。

但需要特别注意:

不要将用户输入直接拼接进 SQL 查询语句。

错误示例:

java 复制代码
String sql =
    "SELECT * FROM users WHERE name = '" + name + "'";

这种方式可能引发 SQL 注入风险。

推荐使用参数化查询:

java 复制代码
String sql = "SELECT * FROM users WHERE name = ?";

再通过 JDBC、JdbcTemplate、MyBatis 等框架提供的参数绑定功能传入具体值。

StringBuilder 能提高字符串构建效率,但不能替代 SQL 参数化带来的安全保障。


九、核心知识点

Q1:StringBuilder 和 String 有什么区别?

String 不可变,StringBuilder 可变。

StringBuilder 适合反复追加、插入、删除字符的场景。

Q2:StringBuilder 和 StringBuffer 有什么区别?

主要区别是同步机制。

StringBuilder 不保证线程安全;StringBuffer 对相关操作提供同步保障。

普通局部字符串操作通常优先使用 StringBuilder。

Q3:StringBuilder 默认容量是多少?

默认无参构造的初始容量为 16 个字符单位。

容量不足时会自动扩容。

Q4:StringBuilder 为什么比循环使用 String + 通常更高效?

因为它可以复用内部可变存储区域,减少反复构造新字符串结果所带来的开销。

但简单拼接场景下不能认为 StringBuilder 一定更快。

Q5:StringBuilder 的 equals() 比较内容吗?

不是。

StringBuilder 没有重写 Object 的 equals(),默认比较对象身份。

比较内容可以转换为 String 后使用 equals(),或者使用 String 的 contentEquals()。

Q6:StringJoiner 和 StringBuilder 有什么区别?

StringBuilder 提供通用字符序列操作能力。

StringJoiner 专门用于按照分隔符连接字符串,并且可以指定前缀与后缀。

Q7:StringBuilder 是不是线程不安全,所以后端不能使用?

不是。

线程安全需要结合对象是否被多个线程共享来判断。

在方法内部创建并只由当前线程使用的 StringBuilder,通常不需要额外同步。

Q8:StringBuilder.toString() 后修改 Builder,会影响之前的 String 吗?

不会。

生成的 String 对象是不可变的,后续修改 StringBuilder 不会改变它的内容。


十、Java 与 JavaScript 对比

需求 Java JavaScript
普通字符串拼接 "a" + "b" "a" + "b"
可变字符串构建 StringBuilder 通常使用数组累积后 join,或直接拼接
反转简单字符串 StringBuilder.reverse() split("").reverse().join("")
数组/集合连接 String.join() Array.join()
字符串长度 length() length
字符串是否可变 String 不可变 string 不可变

需要注意:JavaScript 中没有 StringBuilder 的直接内置对应类。

另外,JS 引擎也会优化字符串拼接,不能认为 JavaScript 的字符串拼接一定低效。

对于有前端出身的盆友,可以重点记住:

  • Java 提供专门的可变字符串类。

  • StringBuilder 的 API 可以直接修改当前字符序列。

  • Java 的 StringJoiner 与 JS 的 Array.join() 在使用目标上比较接近。

  • Java 需要明确考虑共享可变对象的并发安全问题。


十一、总结

Java 字符串处理工具的核心知识:

  1. StringBuilder:可变字符串工具,适合频繁拼接和修改。

  2. StringBuffer:具有同步机制的可变字符串类。

  3. StringJoiner:适合带分隔符、前缀和后缀的字符串连接。

  4. 容量机制:StringBuilder 通过维护可扩展缓冲区实现高效追加。

  5. 性能优化 :简单拼接直接使用 +,循环累积优先考虑 StringBuilder。

  6. 线程安全:重点关注对象是否在线程间共享,而不是只看类名称。

  7. 内容比较:StringBuilder 的 equals() 不会直接比较字符内容。

  8. 后端实践:选择适合的字符串 API,同时注意空值、参数校验及 SQL 注入风险。

最终记忆

复制代码
普通字符串:String

循环拼接:StringBuilder

共享可变字符串:StringBuffer(或其他同步方案)

分隔符拼接:StringJoiner

集合拼接:String.join()

Stream 拼接:Collectors.joining()

对于 Java 后端开发,最常使用的仍然是 String 和 StringBuilder,而 StringJoiner、StringBuffer 需要根据具体场景选择。


参考资料

相关推荐
Risehuxyc11 分钟前
C# 发展历史
开发语言·c#
七夜zippoe1 小时前
Nexent 知识库:调优靠 Chunk 与重排
开发语言·python·ai智能体·nexent·知识库与rag
.痞老板.2 小时前
java ee--文件操作和IO
java·java-ee
简 洁 冬冬2 小时前
分页「向上取整」公式 `(total + size - 1) / size` 的完整推导
java·分页
kyle~2 小时前
C# --- 反射
开发语言·c#
soso19683 小时前
低功耗设计与BMS开发指南
c语言·开发语言·汇编
装不满的克莱因瓶4 小时前
【从零搭建】AI大模型之ReactAgent智能体对接MCP实战
java·人工智能·ai·springai·mcp·springaialibaba
Risehuxyc4 小时前
来自PHP项目devnexen的回信
开发语言·php
FRing034 小时前
vue2干货总结10(json-server、vant-ui、postcss插件、axios二次封装、图形验证码、toast轻提示)
开发语言·前端·vue.js·ui·json·vue2·postcss