在Java编程中，字符串操作是日常开发中最频繁的任务之一。然而，由于String类的不可变性，频繁拼接或修改字符串会导致大量临时对象的创建，从而影响性能。为了解决这个问题，Java提供了StringBuffer和StringBuilder类，它们都是可变的字符序列。本文将重点深入探讨StringBuffer，详细解析其常用方法，并通过实战技巧展示如何高效拼接、修改字符串，同时避免常见陷阱。

1. StringBuffer简介与核心特性

StringBuffer是Java中一个线程安全的可变字符序列。这意味着在多线程环境下，对StringBuffer的修改操作是安全的，不会出现数据不一致的问题。它内部使用一个字符数组来存储数据，并在需要时自动扩容。

与String和StringBuilder的对比：

  • String：不可变，每次修改都会创建新对象，适合字符串内容不经常变化的场景。
  • StringBuilder：可变，非线程安全，性能最高，适合单线程环境下的字符串操作。
  • StringBuffer：可变，线程安全，性能略低于StringBuilder，但适合多线程环境。

选择建议：

  • 如果是单线程环境，优先使用StringBuilder以获得最佳性能。
  • 如果是多线程环境，且需要保证线程安全，则使用StringBuffer。
  • 如果字符串内容基本不变，使用String即可。

2. StringBuffer常用方法详解

2.1 构造方法

StringBuffer提供了多种构造方法，方便我们根据不同的需求创建实例。

// 1. 创建一个空的StringBuffer，初始容量为16
StringBuffer sb1 = new StringBuffer();

// 2. 创建一个指定初始容量的StringBuffer
StringBuffer sb2 = new StringBuffer(100);

// 3. 创建一个包含指定字符串内容的StringBuffer
StringBuffer sb3 = new StringBuffer("Hello");

// 4. 从另一个StringBuffer创建（复制）
StringBuffer sb4 = new StringBuffer(sb3);

实战技巧：如果预估字符串长度较大，建议在构造时指定初始容量，避免频繁扩容带来的性能开销。例如，如果知道最终字符串长度约为500，可以创建new StringBuffer(500)。

2.2 增加（追加）方法：append()

append()方法是StringBuffer最常用的方法之一，用于在字符串末尾追加内容。它接受各种类型的参数，包括基本数据类型、对象、字符数组等。

StringBuffer sb = new StringBuffer();

// 追加字符串
sb.append("Hello");
sb.append(" World");
System.out.println(sb); // 输出: Hello World

// 追加基本数据类型
sb.append(123);
sb.append(3.14);
sb.append(true);
System.out.println(sb); // 输出: Hello World1233.14true

// 追加字符数组
char[] chars = {'J', 'a', 'v', 'a'};
sb.append(chars);
System.out.println(sb); // 输出: Hello World1233.14trueJava

// 追加对象（自动调用toString()方法）
sb.append(new StringBuilder(" StringBuilder"));
System.out.println(sb); // 输出: Hello World1233.14trueJava StringBuilder

实战技巧：在循环中拼接字符串时，使用append()方法可以显著提高性能。例如，拼接10000个数字：

// 低效方式（使用String）
String result = "";
for (int i = 0; i < 10000; i++) {
    result += i; // 每次循环都会创建新String对象
}

// 高效方式（使用StringBuffer）
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 10000; i++) {
    sb.append(i); // 只在同一个对象上操作
}
String result = sb.toString();

2.3 插入方法：insert()

insert()方法用于在指定位置插入内容。它接受两个参数：插入位置的索引和要插入的内容。

StringBuffer sb = new StringBuffer("Hello World");

// 在索引5处插入字符串
sb.insert(5, " Beautiful");
System.out.println(sb); // 输出: Hello Beautiful World

// 在索引0处插入字符
sb.insert(0, '!');
System.out.println(sb); // 输出: !Hello Beautiful World

// 在索引15处插入整数
sb.insert(15, 123);
System.out.println(sb); // 输出: !Hello Beautiful 123World

// 在索引20处插入布尔值
sb.insert(20, false);
System.out.println(sb); // 输出: !Hello Beautiful 123Worldfalse

注意事项：

  • 插入位置必须在0到当前长度之间，否则会抛出StringIndexOutOfBoundsException。
  • 插入操作会移动后续字符，因此对于大量插入操作，性能可能受到影响。

2.4 删除方法：delete() 和 deleteCharAt()

delete()方法用于删除指定范围内的字符，deleteCharAt()用于删除指定位置的单个字符。

StringBuffer sb = new StringBuffer("Hello World");

// 删除索引5到10（不包括10）的字符
sb.delete(5, 10);
System.out.println(sb); // 输出: Hello d

// 删除索引5的字符
sb.deleteCharAt(5);
System.out.println(sb); // 输出: Hellod

// 删除整个字符串
sb.delete(0, sb.length());
System.out.println(sb); // 输出: (空字符串)

实战技巧：在处理用户输入或数据清洗时，可以使用delete()方法移除不需要的字符。例如，移除字符串中的所有空格：

StringBuffer sb = new StringBuffer("Hello   World  Java");
for (int i = 0; i < sb.length(); i++) {
    if (sb.charAt(i) == ' ') {
        sb.deleteCharAt(i);
        i--; // 因为删除了一个字符，索引需要回退
    }
}
System.out.println(sb); // 输出: HelloWorldJava

2.5 替换方法：replace()

replace()方法用于将指定范围内的字符替换为新的内容。

StringBuffer sb = new StringBuffer("Hello World");

// 将索引6到11的字符替换为"Java"
sb.replace(6, 11, "Java");
System.out.println(sb); // 输出: Hello Java

// 将整个字符串替换
sb.replace(0, sb.length(), "New String");
System.out.println(sb); // 输出: New String

注意事项：

  • 替换范围的起始索引必须小于结束索引，且都在有效范围内。
  • 如果替换内容长度与原范围长度不同，字符串长度会相应变化。

2.6 反转方法：reverse()

reverse()方法用于反转字符串中的字符顺序。

StringBuffer sb = new StringBuffer("Hello World");
sb.reverse();
System.out.println(sb); // 输出: dlroW olleH

// 再次反转恢复原状
sb.reverse();
System.out.println(sb); // 输出: Hello World

实战技巧：反转操作常用于字符串处理算法，如判断回文字符串。

// 判断是否为回文字符串
public static boolean isPalindrome(String str) {
    StringBuffer sb = new StringBuffer(str);
    return sb.toString().equals(sb.reverse().toString());
}

// 测试
System.out.println(isPalindrome("level")); // 输出: true
System.out.println(isPalindrome("hello")); // 输出: false

2.7 获取子字符串：substring()

substring()方法用于获取指定范围内的子字符串，返回一个新的String对象。

StringBuffer sb = new StringBuffer("Hello World");

// 获取索引0到5（不包括5）的子字符串
String sub1 = sb.substring(0, 5);
System.out.println(sub1); // 输出: Hello

// 获取从索引6开始到末尾的子字符串
String sub2 = sb.substring(6);
System.out.println(sub2); // 输出: World

注意事项：substring()方法返回的是String对象，而不是StringBuffer对象。如果需要继续修改，需要重新创建StringBuffer。

2.8 其他常用方法

  • length()：返回当前字符序列的长度。
  • capacity()：返回当前容量（内部数组的大小）。
  • ensureCapacity(int minimumCapacity)：确保容量至少为指定值，避免频繁扩容。
  • setLength(int newLength)：设置字符序列的长度。如果新长度小于当前长度，会截断；如果大于当前长度，会用空字符填充。
  • charAt(int index)：获取指定索引处的字符。
  • getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)：将字符序列复制到字符数组中。
StringBuffer sb = new StringBuffer("Hello World");

// 获取长度
int len = sb.length(); // 11

// 获取容量
int cap = sb.capacity(); // 27（初始容量16，追加后自动扩容）

// 确保容量
sb.ensureCapacity(100);

// 设置长度
sb.setLength(5); // 截断为"Hello"
System.out.println(sb); // 输出: Hello

// 获取字符
char c = sb.charAt(0); // 'H'

// 复制到字符数组
char[] dst = new char[5];
sb.getChars(0, 5, dst, 0);
System.out.println(dst); // 输出: Hello

3. 实战技巧：高效拼接与修改字符串

3.1 大数据量拼接

在处理大量数据拼接时，如生成CSV文件、日志记录等，使用StringBuffer可以显著提高性能。

// 示例：生成一个包含10000行数据的CSV文件内容
public static String generateCSV() {
    StringBuffer sb = new StringBuffer();
    
    // 添加表头
    sb.append("ID,Name,Age\n");
    
    // 添加数据行
    for (int i = 1; i <= 10000; i++) {
        sb.append(i).append(",User").append(i).append(",").append(20 + i % 50).append("\n");
    }
    
    return sb.toString();
}

// 测试性能
long start = System.currentTimeMillis();
String csv = generateCSV();
long end = System.currentTimeMillis();
System.out.println("生成CSV耗时: " + (end - start) + "ms");

性能优化建议：

  1. 预估容量：如果知道大致的字符串长度，可以在构造时指定初始容量。
  2. 避免频繁toString()：在拼接过程中，尽量减少toString()的调用，因为每次调用都会创建新的String对象。
  3. 批量操作：对于大量数据，考虑分批处理，避免单次操作内存占用过大。

3.2 多线程环境下的使用

由于StringBuffer是线程安全的，它可以在多线程环境中安全使用。但需要注意，线程安全并不意味着所有操作都是原子的。

// 示例：多线程环境下拼接字符串
public class StringBufferExample {
    private static final StringBuffer sharedBuffer = new StringBuffer();
    
    public static void main(String[] args) throws InterruptedException {
        // 创建多个线程
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            final int threadId = i;
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 100; j++) {
                    sharedBuffer.append("Thread").append(threadId).append("-").append(j).append(" ");
                }
            });
        }
        
        // 启动所有线程
        for (Thread t : threads) {
            t.start();
        }
        
        // 等待所有线程完成
        for (Thread t : threads) {
            t.join();
        }
        
        System.out.println("最终结果长度: " + sharedBuffer.length());
    }
}

注意事项：

  • 虽然StringBuffer的方法是同步的，但多个方法调用的组合可能不是原子的。例如，先检查长度再修改，可能需要额外的同步。
  • 如果对性能要求极高，且多线程竞争不激烈，可以考虑使用StringBuilder配合外部同步机制。

3.3 字符串处理技巧

3.3.1 高效移除重复字符

public static String removeDuplicates(String str) {
    if (str == null || str.length() == 0) {
        return str;
    }
    
    StringBuffer sb = new StringBuffer();
    boolean[] seen = new boolean[256]; // 假设ASCII字符
    
    for (int i = 0; i < str.length(); i++) {
        char c = str.charAt(i);
        if (!seen[c]) {
            sb.append(c);
            seen[c] = true;
        }
    }
    
    return sb.toString();
}

// 测试
System.out.println(removeDuplicates("hello world")); // 输出: helo wrd

3.3.2 高效反转单词

public static String reverseWords(String str) {
    if (str == null || str.length() == 0) {
        return str;
    }
    
    // 先反转整个字符串
    StringBuffer sb = new StringBuffer(str);
    sb.reverse();
    
    // 再反转每个单词
    int start = 0;
    for (int i = 0; i < sb.length(); i++) {
        if (sb.charAt(i) == ' ') {
            reverseRange(sb, start, i - 1);
            start = i + 1;
        }
    }
    // 反转最后一个单词
    reverseRange(sb, start, sb.length() - 1);
    
    return sb.toString();
}

private static void reverseRange(StringBuffer sb, int start, int end) {
    while (start < end) {
        char temp = sb.charAt(start);
        sb.setCharAt(start, sb.charAt(end));
        sb.setCharAt(end, temp);
        start++;
        end--;
    }
}

// 测试
System.out.println(reverseWords("hello world java")); // 输出: java world hello

4. 常见陷阱与避免方法

4.1 陷阱1：错误地使用StringBuffer与String的转换

问题：频繁在StringBuffer和String之间转换，导致性能下降。

// 错误示例
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 10000; i++) {
    sb.append(i);
    String temp = sb.toString(); // 每次循环都创建新String对象
    // ... 使用temp进行其他操作
}

// 正确做法：只在最后转换一次
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 10000; i++) {
    sb.append(i);
}
String result = sb.toString();

4.2 陷阱2：忽略初始容量导致频繁扩容

问题：默认初始容量为16，当字符串长度超过16时，会触发扩容，影响性能。

// 错误示例：频繁扩容
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 1000; i++) {
    sb.append(i); // 可能多次扩容
}

// 正确做法：指定初始容量
StringBuffer sb = new StringBuffer(1000); // 预估长度
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}

4.3 陷阱3：在循环中使用+运算符拼接字符串

问题：在循环中使用+拼接字符串，会导致大量临时对象的创建。

// 错误示例
String result = "";
for (int i = 0; i < 10000; i++) {
    result += i; // 每次循环创建新String对象
}

// 正确做法：使用StringBuffer
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 10000; i++) {
    sb.append(i);
}
String result = sb.toString();

4.4 陷阱4：误解线程安全的范围

问题：认为StringBuffer的所有操作都是原子的，导致多线程问题。

// 错误示例：非原子操作
public class Counter {
    private StringBuffer buffer = new StringBuffer();
    
    public void increment() {
        // 这两个操作不是原子的
        buffer.append("1");
        buffer.append("2");
    }
}

// 正确做法：使用同步块
public class Counter {
    private StringBuffer buffer = new StringBuffer();
    
    public void increment() {
        synchronized (buffer) {
            buffer.append("1");
            buffer.append("2");
        }
    }
}

4.5 陷阱5：误用deleteCharAt()导致索引错误

问题：在循环中删除字符时，忘记调整索引，导致跳过某些字符。

// 错误示例
StringBuffer sb = new StringBuffer("Hello World");
for (int i = 0; i < sb.length(); i++) {
    if (sb.charAt(i) == 'o') {
        sb.deleteCharAt(i); // 删除后，后面的字符前移，但i继续增加
    }
}
System.out.println(sb); // 输出: Hell Wrld（漏掉了第二个o）

// 正确做法：删除后索引回退
StringBuffer sb = new StringBuffer("Hello World");
for (int i = 0; i < sb.length(); i++) {
    if (sb.charAt(i) == 'o') {
        sb.deleteCharAt(i);
        i--; // 因为删除了一个字符，索引需要回退
    }
}
System.out.println(sb); // 输出: Hell Wrld（正确）

5. 性能对比与最佳实践

5.1 性能对比测试

下面是一个简单的性能测试，比较String、StringBuffer和StringBuilder在拼接大量字符串时的性能。

public class StringPerformanceTest {
    private static final int ITERATIONS = 100000;
    
    public static void main(String[] args) {
        testString();
        testStringBuffer();
        testStringBuilder();
    }
    
    private static void testString() {
        long start = System.currentTimeMillis();
        String result = "";
        for (int i = 0; i < ITERATIONS; i++) {
            result += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("String耗时: " + (end - start) + "ms");
    }
    
    private static void testStringBuffer() {
        long start = System.currentTimeMillis();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < ITERATIONS; i++) {
            sb.append(i);
        }
        String result = sb.toString();
        long end = System.currentTimeMillis();
        System.out.println("StringBuffer耗时: " + (end - start) + "ms");
    }
    
    private static void testStringBuilder() {
        long start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < ITERATIONS; i++) {
            sb.append(i);
        }
        String result = sb.toString();
        long end = System.currentTimeMillis();
        System.out.println("StringBuilder耗时: " + (end - start) + "ms");
    }
}

典型结果（在普通PC上）：

  • String: 5000-10000ms
  • StringBuffer: 50-100ms
  • StringBuilder: 30-60ms

5.2 最佳实践总结

  1. 选择合适的类：

    • 单线程环境：优先使用StringBuilder。
    • 多线程环境：使用StringBuffer。
    • 字符串内容不变：使用String。

  2. 预估容量：在构造时指定初始容量，避免频繁扩容。

  3. 减少转换次数：尽量在最后调用toString()，避免中间转换。

  4. 避免在循环中使用+：循环中拼接字符串时，使用append()方法。

  5. 注意线程安全：虽然StringBuffer是线程安全的，但复合操作可能需要额外同步。

  6. 合理使用方法：根据需求选择合适的方法，如append()、insert()、replace()等。

  7. 性能敏感场景：在性能要求极高的场景，考虑使用StringBuilder配合外部同步，或使用其他数据结构。

6. 总结

StringBuffer作为Java中可变的字符序列，在字符串拼接和修改操作中提供了线程安全的解决方案。通过掌握其常用方法和实战技巧，我们可以高效地处理字符串操作，避免常见陷阱。在实际开发中，应根据具体场景选择合适的字符串处理类，并遵循最佳实践，以达到最佳的性能和代码质量。

记住，虽然StringBuffer功能强大，但在单线程环境下，StringBuilder通常是更好的选择。理解它们之间的差异和适用场景，是编写高效Java代码的关键。