【Java】StringBuffer与StringBuilder详解

目录

一、基本概念

1.核心区别

2.底层实现

3.StringBuffer与StringBuilder内部实现与扩容机制

⑴核心源码结构

⑵底层数据结构

⑶扩容机制

⑷初始化容量

 ⑸添加字符的流程（以 append(String str) 为例）

⑹ 扩容示例

二、StringBuffer和StringBuilder构造方法

1. 无参构造方法

2. 带初始容量参数的构造方法

3. 带字符串参数的构造方法

4. 带 CharSequence 参数的构造方法（Java 5 及以上）

三、常用方法

1. 追加方法

2. 删除方法

3. 插入方法

4. 替换方法

5. 反转方法

6. 设置方法

7. 获取字符方法

8. 查找方法

9. 长度和子字符串方法

10. 转换为字符串方法

四、String、StringBuilder 和 StringBuffer 的效率对比和优化策略的详细解析

1. 问题根源：String 的不可变性

2. StringBuilder 的高效性

3. StringBuffer 的线程安全代价

4. 性能优化策略

(1) 预分配容量

(2) 避免隐式转换

5. 效率对比总结

6. 实际测试数据

7. 总结与建议

---

一、基本概念

String类：

String类是不可变的，一旦创建了一个String对象，它的值就不能被改变。如果对String对象进行拼接、替换等操作，实际上是创建了一个新的String对象。

StringBuffer类：

StringBuffer是线程安全的可变字符序列。它的所有公共方法都是同步的，这意味着在多线程环境下可以安全地使用，但在单线程环境下会有一定的性能开销。

StringBuilder类：

StringBuilder是StringBuffer的非线程安全版本，从 Java 5 开始引入。它的方法没有进行同步处理，因此在单线程环境下性能比StringBuffer更高。

在Java中，StringBuffer和StringBuilder是专为频繁字符串拼接设计的可变字符串类，其核心区别和实现细节如下：

1.核心区别

线程安全：

①StringBuffer是线程安全的（方法使用synchronized修饰），适用于多线程环境。

②StringBuilder非线程安全，单线程下效率更高。

出现时间：

StringBuffer自Java 1.0引入，StringBuilder于Java 5新增。

2.底层实现

Java 8及之前：底层使用char[ ]存储字符。

Java 9及之后：优化为byte[ ]，根据字符编码动态选择Latin-1（1字节/字符）或UTF-16（2字节/字符），节省内存。

3.StringBuffer与StringBuilder内部实现与扩容机制

在Java中，StringBuilder和StringBuffer的核心实现逻辑继承自同一个父类 AbstractStringBuilder，两者的区别仅在于线程安全性（StringBuffer的方法用synchronized修饰）。

⑴核心源码结构

①继承关系

StringBuilder 和 StringBuffer 均继承自 AbstractStringBuilder：

// JDK 17 源码
public final class StringBuilder extends AbstractStringBuilder {
    // 方法未同步
}

public final class StringBuffer extends AbstractStringBuilder {
    // 方法用 synchronized 修饰
}

AbstractStringBuilder：包含核心的字符数组存储（byte[ ] value）、扩容逻辑和操作方法（append(), insert()等）。

② 扩容代码位置

扩容方法定义在 AbstractStringBuilder 中，StringBuilder 和 StringBuffer 直接继承这些方法。 例如 ensureCapacityInternal(), newCapacity() 等扩容逻辑，两者完全共用同一份实现。

它们的底层数据结构、扩容机制完全一致。以下是基于 JDK 17 源码的深入解析：

⑵底层数据结构

两者均通过 动态字符数组 存储数据，继承自 AbstractStringBuilder，核心字段如下：

// AbstractStringBuilder 类源码
abstract class AbstractStringBuilder {
    byte[] value;     // JDK 9 后改为 byte[]（优化内存，支持压缩字符串）
    int count;        // 当前实际字符数（非数组长度）
    // ...
}

value：存储字符的数组，初始容量由构造器决定。

count：记录当前实际存储的字符数（即字符串长度）。

JDK 9+优化：从 char[ ] 改为 byte[ ]，结合编码标志（coder）压缩存储（LATIN1或UTF16），节省内存。

⑶扩容机制

当添加字符导致 count + 1 > value.length 时触发扩容。核心方法是 ensureCapacityInternal(int minimumCapacity)。

源码分析（JDK 17）

/**
 * 确保内部数组的容量足够，如果当前容量不足，则触发扩容操作。
 *
 * @param minimumCapacity 所需的最小容量
 */
private void ensureCapacityInternal(int minimumCapacity) {
    // 当前容量不足时触发扩容
    // minimumCapacity 为所需的最小容量，value.length 为当前数组的容量
    // 若所需最小容量大于当前数组容量，则需要进行扩容
    if (minimumCapacity - value.length > 0) {
        // 调用 newCapacity 方法计算新的容量，并使用 Arrays.copyOf 方法将原数组复制到新容量的数组中
        value = Arrays.copyOf(value, newCapacity(minimumCapacity));
    }
}

/**
 * 计算新的数组容量。
 *
 * @param minCapacity 所需的最小容量
 * @return 计算得到的新容量
 */
private int newCapacity(int minCapacity) {
    // 获取当前数组的容量
    int oldCapacity = value.length;
    // 默认扩容策略：旧容量 * 2 + 2
    // 使用左移操作符 << 实现乘以 2 的效果，效率更高
    int newCapacity = (oldCapacity << 1) + 2;
    // 若扩容后的容量仍小于所需的最小容量，则直接使用所需的最小容量作为新容量
    if (newCapacity - minCapacity < 0) {
        newCapacity = minCapacity;
    }
    // 检查计算得到的新容量是否合法，是否超过最大容量（MAX_ARRAY_SIZE，通常为 Integer.MAX_VALUE - 8）
    // 如果新容量小于等于 0 或者超过了最大容量限制，则调用 hugeCapacity 方法处理
    return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
}

/**
 * 处理大容量需求的情况。
 *
 * @param minCapacity 所需的最小容量
 * @return 最终确定的大容量
 * @throws OutOfMemoryError 如果所需容量超过了 Integer.MAX_VALUE，抛出内存溢出异常
 */
private int hugeCapacity(int minCapacity) {
    // 检查所需的最小容量是否超过了 Integer.MAX_VALUE，如果超过则会发生溢出
    if (Integer.MAX_VALUE - minCapacity < 0) {
        // 若超过 Integer.MAX_VALUE，抛出内存溢出异常
        throw new OutOfMemoryError();
    }
    // 如果所需的最小容量大于最大容量（MAX_ARRAY_SIZE），则使用所需的最小容量
    // 否则使用最大容量
    return (minCapacity > MAX_ARRAY_SIZE) ? minCapacity : MAX_ARRAY_SIZE;
}

扩容规则

默认扩容策略：新容量 = 旧容量 * 2 + 2。

特殊场景：若所需容量（minCapacity）超过默认扩容后的值，直接使用 minCapacity。

容量上限：最大为 Integer.MAX_VALUE - 8（MAX_ARRAY_SIZE），超过则可能抛出 OutOfMemoryError。

⑷初始化容量

不同构造器初始化容量方式不同：

①无参构造器

// StringBuilder 无参构造器
public StringBuilder() {
    super(16);  // 调用 AbstractStringBuilder(int capacity)
}

// AbstractStringBuilder 初始化
AbstractStringBuilder(int capacity) {
    value = (capacity == 0) 
        ? new byte[0] 
        : new byte[capacity];
    coder = (byte)(String.COMPACT_STRINGS ? String.LATIN1 : String.UTF16);
}

• 默认容量为16（若未指定）。

 ②指定初始容量

public StringBuilder(int capacity) {
    super(capacity);
}

 ③基于字符串初始化

public StringBuilder(String str) {
    super(str.length() + 16);  // 初始容量 = 字符串长度 + 16
    append(str);
}

 ⑸添加字符的流程（以 append(String str) 为例）

public AbstractStringBuilder append(String str) {
    if (str == null) {
        return appendNull();  // 处理 null
    }
    int len = str.length();
    ensureCapacityInternal(count + len);  // 检查容量
    putStringAt(count, str);              // 将字符串复制到 value 数组
    count += len;                         // 更新字符数
    return this;
}

容量检查：调用 ensureCapacityInternal，若不足则扩容。

数据复制：将新字符串内容复制到 value 数组中。

更新长度：count 增加新字符数。

⑹ 扩容示例

假设初始容量为 5，依次添加字符串 "HelloWorld"：

操作	当前容量	扩容逻辑	新容量
初始容量	5	-	5
添加 "Hello" (5字符)	5 → 不足	新容量 = 5*2 + 2 = 12	12
继续添加 "World" (5)	12 - 10 = 2	剩余容量足够，无需扩容	12
再添加 "!" (1)	12 - 11 = 1	剩余容量足够，无需扩容	12

⑺操作方法的差异

StringBuilder 的方法：直接调用父类方法，无同步。

// StringBuilder 的 append 方法
@Override
public StringBuilder append(String str) {
    super.append(str);  // 调用 AbstractStringBuilder.append()
    return this;
}

StringBuffer 的方法：通过 synchronized 保证线程安全。

// StringBuffer 的 append 方法
@Override
public synchronized StringBuffer append(String str) {
    toStringCache = null;  // JDK 17 前存在，现已移除
    super.append(str);     // 同样调用 AbstractStringBuilder.append()
    return this;
}

维度	StringBuilder	StringBuffer
线程安全	非线程安全	线程安全（方法用synchronized）
扩容机制	与StringBuffer完全相同	与StringBuilder完全相同
性能	高（无同步开销）	较低（同步开销）
底层存储	共享AbstractStringBuilder的byte[ ] value	同上

二、StringBuffer和StringBuilder构造方法

1. 无参构造方法

功能：创建一个初始容量为 16 个字符的空对象。当存储的字符数量超过 16 时，会自动进行扩容。

示例代码：

public class ConstructorExample {
    public static void main(String[] args) {
        // 使用无参构造方法创建 StringBuffer 对象
        StringBuffer stringBuffer = new StringBuffer();
        // 使用无参构造方法创建 StringBuilder 对象
        StringBuilder stringBuilder = new StringBuilder();

        System.out.println("StringBuffer 初始长度: " + stringBuffer.length());
        System.out.println("StringBuilder 初始长度: " + stringBuilder.length());
    }
}

运行结果：

2. 带初始容量参数的构造方法

功能：创建一个指定初始容量的空对象。当需要处理大量字符且大致知道所需容量时，使用此构造方法可以避免多次扩容带来的性能开销。

public class ConstructorExample {
    public static void main(String[] args) {
        // 创建一个初始容量为 32 的 StringBuffer 对象
        StringBuffer stringBuffer = new StringBuffer(32);
        // 创建一个初始容量为 32 的 StringBuilder 对象
        StringBuilder stringBuilder = new StringBuilder(32);

        System.out.println("StringBuffer 初始容量: " + stringBuffer.capacity());
        System.out.println("StringBuilder 初始容量: " + stringBuilder.capacity());
    }
}

运行结果：

3. 带字符串参数的构造方法

功能：创建一个包含指定字符串内容的对象，初始容量为字符串的长度加上 16。

public class ConstructorExample {
    public static void main(String[] args) {
        String str = "Hello";
        // 创建一个包含指定字符串的 StringBuffer 对象
        StringBuffer stringBuffer = new StringBuffer(str);
        // 创建一个包含指定字符串的 StringBuilder 对象
        StringBuilder stringBuilder = new StringBuilder(str);

        System.out.println("StringBuffer 内容: " + stringBuffer.toString());
        System.out.println("StringBuilder 内容: " + stringBuilder.toString());
        System.out.println("StringBuffer 容量: " + stringBuffer.capacity());
        System.out.println("StringBuilder 容量: " + stringBuilder.capacity());
    }
}

运行结果：

4. 带 CharSequence 参数的构造方法（Java 5 及以上）

功能：创建一个包含指定 CharSequence 内容的对象。CharSequence 是一个接口，String、StringBuffer、StringBuilder 等类都实现了该接口。

public class ConstructorExample {
    public static void main(String[] args) {
        CharSequence charSequence = "World";
        // 创建一个包含指定 CharSequence 的 StringBuffer 对象
        StringBuffer stringBuffer = new StringBuffer(charSequence);
        // 创建一个包含指定 CharSequence 的 StringBuilder 对象
        StringBuilder stringBuilder = new StringBuilder(charSequence);

        System.out.println("StringBuffer 内容: " + stringBuffer.toString());
        System.out.println("StringBuilder 内容: " + stringBuilder.toString());
    }
}

运行结果:

三、常用方法

---

1. 追加方法

append(Type data)

语法：StringBuffer append(Type data) 或 StringBuilder append(Type data)

功能：将指定类型的数据追加到当前对象的末尾。Type 可以是 String、char、int、double 等多种类型。

示例：

public class AppendExample {
    public static void main(String[] args) {
        // StringBuffer append
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("Hello").append(" ").append("World");
        System.out.println("StringBuffer append 结果: " + stringBuffer.toString());

        // StringBuilder append
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(123).append(true);
        System.out.println("StringBuilder append 结果: " + stringBuilder.toString());
    }
}

运行结果：

---

2. 删除方法

delete(int start, int end)

语法：StringBuffer delete(int start, int end) 或 StringBuilder delete(int start, int end)

功能：移除从索引 start（包含）到索引 end（不包含）之间的字符序列。

示例：

public class DeleteExample {
    public static void main(String[] args) {
        // StringBuffer delete
        StringBuffer stringBuffer = new StringBuffer("HelloWorld");
        stringBuffer.delete(5, 10);
        System.out.println("StringBuffer delete 结果: " + stringBuffer.toString());

        // StringBuilder delete
        StringBuilder stringBuilder = new StringBuilder("HelloWorld");
        stringBuilder.delete(5, 10);
        System.out.println("StringBuilder delete 结果: " + stringBuilder.toString());
    }
}

运行结果：

---

deleteCharAt(int index)

语法：StringBuffer deleteCharAt(int index) 或 StringBuilder deleteCharAt(int index)

功能：移除指定索引位置的字符。

示例：

public class DeleteCharAtExample {
    public static void main(String[] args) {
        // StringBuffer deleteCharAt
        StringBuffer stringBuffer = new StringBuffer("Hello");
        stringBuffer.deleteCharAt(1);
        System.out.println("StringBuffer deleteCharAt 结果: " + stringBuffer.toString());

        // StringBuilder deleteCharAt
        StringBuilder stringBuilder = new StringBuilder("Hello");
        stringBuilder.deleteCharAt(1);
        System.out.println("StringBuilder deleteCharAt 结果: " + stringBuilder.toString());
    }
}

运行结果：

---

3. 插入方法

insert(int offset, String str)

语法：StringBuffer insert(int offset, String str) 或 StringBuilder insert(int offset, String str)

功能：在指定的偏移量 offset 处插入指定的字符串 str。

示例：

public class InsertExample {
    public static void main(String[] args) {
        // StringBuffer insert
        StringBuffer stringBuffer = new StringBuffer("Hello");
        stringBuffer.insert(5, " World");
        System.out.println("StringBuffer insert 结果: " + stringBuffer.toString());

        // StringBuilder insert
        StringBuilder stringBuilder = new StringBuilder("Hello");
        stringBuilder.insert(5, " World");
        System.out.println("StringBuilder insert 结果: " + stringBuilder.toString());
    }
}

运行结果：

---

4. 替换方法

replace(int start, int end, String str)

语法：StringBuffer replace(int start, int end, String str) 或 StringBuilder replace(int start, int end, String str)

功能：将从索引 start（包含）到索引 end（不包含）之间的字符序列替换为指定的字符串 str。

示例：

public class ReplaceExample {
    public static void main(String[] args) {
        // StringBuffer replace
        StringBuffer stringBuffer = new StringBuffer("HelloWorld");
        stringBuffer.replace(5, 10, " Java");
        System.out.println("StringBuffer replace 结果: " + stringBuffer.toString());

        // StringBuilder replace
        StringBuilder stringBuilder = new StringBuilder("HelloWorld");
        stringBuilder.replace(5, 10, " Java");
        System.out.println("StringBuilder replace 结果: " + stringBuilder.toString());
    }
}

运行结果:

---

5. 反转方法

reverse()

语法：StringBuffer reverse() 或 StringBuilder reverse()

功能：将当前对象中的字符序列反转。

示例：

public class ReverseExample {
    public static void main(String[] args) {
        // StringBuffer reverse
        StringBuffer stringBuffer = new StringBuffer("Hello");
        stringBuffer.reverse();
        System.out.println("StringBuffer reverse 结果: " + stringBuffer.toString());

        // StringBuilder reverse
        StringBuilder stringBuilder = new StringBuilder("Hello");
        stringBuilder.reverse();
        System.out.println("StringBuilder reverse 结果: " + stringBuilder.toString());
    }
}

运行结果:

---

6. 设置方法

setCharAt(int index, char ch)

语法：void setCharAt(int index, char ch)

功能：将指定索引位置的字符替换为指定的字符 ch。

示例：

public class SetCharAtExample {
    public static void main(String[] args) {
        // StringBuffer setCharAt
        StringBuffer stringBuffer = new StringBuffer("Hello");
        stringBuffer.setCharAt(1, 'a');
        System.out.println("StringBuffer setCharAt 结果: " + stringBuffer.toString());

        // StringBuilder setCharAt
        StringBuilder stringBuilder = new StringBuilder("Hello");
        stringBuilder.setCharAt(1, 'a');
        System.out.println("StringBuilder setCharAt 结果: " + stringBuilder.toString());
    }
}

运行结果：

---

setLength(int newLength)

语法：void setLength(int newLength)

功能：设置当前对象的长度。如果 newLength 小于当前长度，则会截断字符序列；如果 newLength 大于当前长度，则会在末尾填充空字符（'\0'）。

示例：

public class SetLengthExample {
    public static void main(String[] args) {
        // StringBuffer setLength
        StringBuffer stringBuffer = new StringBuffer("Hello");
        stringBuffer.setLength(3);
        System.out.println("StringBuffer setLength 截断结果: " + stringBuffer.toString());
        stringBuffer.setLength(5);
        System.out.println("StringBuffer setLength 扩充结果: " + stringBuffer.toString());

        // StringBuilder setLength
        StringBuilder stringBuilder = new StringBuilder("Hello");
        stringBuilder.setLength(3);
        System.out.println("StringBuilder setLength 截断结果: " + stringBuilder.toString());
        stringBuilder.setLength(5);
        System.out.println("StringBuilder setLength 扩充结果: " + stringBuilder.toString());
    }
}

运行结果：

---

7. 获取字符方法

charAt(int index)

语法：char charAt(int index)

功能：返回指定索引位置的字符。

示例：

public class CharAtExample {
    public static void main(String[] args) {
        // StringBuffer charAt
        StringBuffer stringBuffer = new StringBuffer("Hello");
        char c1 = stringBuffer.charAt(1);
        System.out.println("StringBuffer charAt 结果: " + c1);

        // StringBuilder charAt
        StringBuilder stringBuilder = new StringBuilder("Hello");
        char c2 = stringBuilder.charAt(1);
        System.out.println("StringBuilder charAt 结果: " + c2);
    }
}

运行结果：

---

8. 查找方法

indexOf(String str)

语法：int indexOf(String str)

功能：返回指定字符串 str 在当前对象中第一次出现的索引位置。如果未找到，则返回 -1。

示例：

public class IndexOfExample {
    public static void main(String[] args) {
        // StringBuffer indexOf
        StringBuffer stringBuffer = new StringBuffer("HelloWorld");
        int index1 = stringBuffer.indexOf("World");
        System.out.println("StringBuffer indexOf 结果: " + index1);

        // StringBuilder indexOf
        StringBuilder stringBuilder = new StringBuilder("HelloWorld");
        int index2 = stringBuilder.indexOf("World");
        System.out.println("StringBuilder indexOf 结果: " + index2);
    }
}

运行结果：

---

indexOf(String str, int fromIndex)

语法：int indexOf(String str, int fromIndex)

功能：从指定的索引 fromIndex 开始，返回指定字符串 str 在当前对象中第一次出现的索引位置。如果未找到，则返回 -1。

示例：

public class IndexOfWithStartExample {
    public static void main(String[] args) {
        // StringBuffer indexOf 带起始位置
        StringBuffer stringBuffer = new StringBuffer("HelloWorldHello");
        int index1 = stringBuffer.indexOf("Hello", 6);
        System.out.println("StringBuffer indexOf 带起始位置结果: " + index1);

        // StringBuilder indexOf 带起始位置
        StringBuilder stringBuilder = new StringBuilder("HelloWorldHello");
        int index2 = stringBuilder.indexOf("Hello", 6);
        System.out.println("StringBuilder indexOf 带起始位置结果: " + index2);
    }
}

运行结果：

---

lastIndexOf(String str)

语法：int lastIndexOf(String str)

功能：返回指定字符串 str 在当前对象中最后一次出现的索引位置。如果未找到，则返回 -1。

示例：

public class LastIndexOfExample {
    public static void main(String[] args) {
        // StringBuffer lastIndexOf
        StringBuffer stringBuffer = new StringBuffer("HelloWorldHello");
        int index1 = stringBuffer.lastIndexOf("Hello");
        System.out.println("StringBuffer lastIndexOf 结果: " + index1);

        // StringBuilder lastIndexOf
        StringBuilder stringBuilder = new StringBuilder("HelloWorldHello");
        int index2 = stringBuilder.lastIndexOf("Hello");
        System.out.println("StringBuilder lastIndexOf 结果: " + index2);
    }
}

运行结果：

---

lastIndexOf(String str, int fromIndex)

语法：int lastIndexOf(String str, int fromIndex)

功能：从指定的索引 fromIndex 开始向前搜索，返回指定字符串 str 在当前对象中最后一次出现的索引位置。如果未找到，则返回 -1。

示例：

public class LastIndexOfWithStartExample {
    public static void main(String[] args) {
        // StringBuffer lastIndexOf 带起始位置
        StringBuffer stringBuffer = new StringBuffer("HelloWorldHello");
        int index1 = stringBuffer.lastIndexOf("Hello", 9);
        System.out.println("StringBuffer lastIndexOf 带起始位置结果: " + index1);

        // StringBuilder lastIndexOf 带起始位置
        StringBuilder stringBuilder = new StringBuilder("HelloWorldHello");
        int index2 = stringBuilder.lastIndexOf("Hello", 9);
        System.out.println("StringBuilder lastIndexOf 带起始位置结果: " + index2);
    }
}

运行结果：

---

9. 长度和子字符串方法

length()

语法：int length()

功能：返回当前对象中字符序列的长度。

示例：

public class LengthExample {
    public static void main(String[] args) {
        // StringBuffer length
        StringBuffer stringBuffer = new StringBuffer("Hello");
        int len1 = stringBuffer.length();
        System.out.println("StringBuffer length 结果: " + len1);

        // StringBuilder length
        StringBuilder stringBuilder = new StringBuilder("Hello");
        int len2 = stringBuilder.length();
        System.out.println("StringBuilder length 结果: " + len2);
    }
}

运行结果：

---

substring(int start)

语法：String substring(int start)

功能：返回从指定索引 start 开始到字符序列末尾的子字符串。

示例：

public class SubstringSingleParamExample {
    public static void main(String[] args) {
        // StringBuffer substring 单参数
        StringBuffer stringBuffer = new StringBuffer("HelloWorld");
        String sub1 = stringBuffer.substring(5);
        System.out.println("StringBuffer substring 单参数结果: " + sub1);

        // StringBuilder substring 单参数
        StringBuilder stringBuilder = new StringBuilder("HelloWorld");
        String sub2 = stringBuilder.substring(5);
        System.out.println("StringBuilder substring 单参数结果: " + sub2);
    }
}

运行结果：

---

substring(int start, int end)

语法：String substring(int start, int end)

功能：返回从索引 start（包含）到索引 end（不包含）之间的子字符串。

示例：

public class SubstringTwoParamsExample {
    public static void main(String[] args) {
        // StringBuffer substring 双参数
        StringBuffer stringBuffer = new StringBuffer("HelloWorld");
        String sub1 = stringBuffer.substring(0, 5);
        System.out.println("StringBuffer substring 双参数结果: " + sub1);

        // StringBuilder substring 双参数
        StringBuilder stringBuilder = new StringBuilder("HelloWorld");
        String sub2 = stringBuilder.substring(0, 5);
        System.out.println("StringBuilder substring 双参数结果: " + sub2);
    }
}

运行结果：

---

10. 转换为字符串方法

toString()

语法：String toString()

功能：将当前对象中的字符序列转换为一个不可变的 String 对象。

示例：

public class ToStringExample {
    public static void main(String[] args) {
        // StringBuffer toString
        StringBuffer stringBuffer = new StringBuffer("Hello");
        String str1 = stringBuffer.toString();
        System.out.println("StringBuffer toString 结果: " + str1);

        // StringBuilder toString
        StringBuilder stringBuilder = new StringBuilder("Hello");
        String str2 = stringBuilder.toString();
        System.out.println("StringBuilder toString 结果: " + str2);
    }
}

运行结果：

四、String、StringBuilder 和 StringBuffer 的效率对比和优化策略的详细解析

1. 问题根源：String 的不可变性

String 是不可变类，每次拼接（如 s += i）都会触发以下操作：

①创建一个新的 StringBuilder 对象（隐式创建）。

②调用 append() 方法将当前 s 和 i 拼接。

③调用 toString() 生成新的 String 对象。

④旧的 String 对象成为垃圾，等待 GC 回收。

示例代码分析：

String s = "";
for (int i = 0; i < 100000; i++) {
    s += i; // 等价于 s = new StringBuilder().append(s).append(i).toString();
}

问题：循环 10 万次会创建 10 万个 StringBuilder 和 String 对象，导致：

       频繁内存分配和对象复制。

       GC 压力剧增（大量短期对象进入年轻代，触发频繁 Minor GC）。

结果：耗时 3827 毫秒，效率极低。

2. StringBuilder 的高效性

StringBuilder 是可变字符序列，底层基于动态扩容的 byte[ ]（或 char[ ]），直接修改原数组，避免频繁对象创建。

示例代码分析：

StringBuilder s = new StringBuilder();
for (int i = 0; i < 100000; i++) {
    s.append(i); // 直接操作底层数组，无需创建新对象
}

优势：

单次对象创建：只初始化一个 StringBuilder 对象。

动态扩容优化：底层数组按需扩容（扩容策略为 原容量*2 + 2）。

无额外 GC 压力：对象复用，减少垃圾产生。

结果：耗时 7 毫秒，效率提升近 400 倍。

3. StringBuffer 的线程安全代价

StringBuffer 与 StringBuilder 功能相同，但所有方法用 synchronized 修饰以保证线程安全。 效率对比：

单线程环境：StringBuffer 因同步锁开销，效率低于 StringBuilder（测试中可能慢 10%~20%）。

多线程环境：需共享变量时，StringBuffer 是唯一选择。

4. 性能优化策略

(1) 预分配容量

默认容量：StringBuilder 初始容量为 16。

扩容成本：每次扩容需复制旧数组到新数组，时间复杂度为 O(n)。

优化方案：预估最终字符串长度，直接指定初始容量。

StringBuilder sb = new StringBuilder(100000); // 直接分配足够空间，避免扩容

5. 效率对比总结

类名	线程安全	单线程效率	适用场景
String	不可变	极低	少量字符串操作或常量定义
StringBuilder	不安全	最高	单线程频繁字符串操作
StringBuffer	安全	中等	多线程共享变量的字符串操作

---

6. 实际测试数据

操作类型	循环次数	耗时（毫秒）
String 拼接	100,000	3827
StringBuilder	100,000	7
StringBuffer	100,000	12~15

---

7. 总结与建议

• 优先选择 StringBuilder：在单线程环境下，始终优先使用 StringBuilder。

• 避免 String 拼接循环：尤其在数据量大时，直接使用 StringBuilder。

• 预分配容量：预估字符串长度，减少扩容次数。

• 多线程场景用 StringBuffer：仅在需要线程安全时使用，否则性能损耗明显。

理解这些差异和优化策略，可以显著提升字符串操作的性能，减少不必要的资源消耗。