核心概念

StringBuilder 提供了内置的 reverse() 方法，可以高效地将字符串内容原地反转。这是处理字符串逆序最推荐的方式，相比手动实现具有更高的性能和更低的出错概率。

✅ 关键点：

  • reverse() 是原地操作（in-place），直接修改原对象
  • 时间复杂度：O(n)
  • 不创建额外的字符串对象（除非调用 toString()）
  • 支持链式调用

操作步骤（非常详细）

步骤 1：创建 StringBuilder 对象

// 方式一：从字符串创建
String original = "Hello";
StringBuilder sb = new StringBuilder(original);

// 方式二：空构造 + append
StringBuilder sb2 = new StringBuilder();
sb2.append("Hello");

// 方式三：指定初始容量（推荐用于大字符串）
StringBuilder sb3 = new StringBuilder(100); // 预设容量
sb3.append("Hello");

步骤 2：调用 reverse() 方法

// 执行逆序操作
sb.reverse();
// 此时 sb 内容已变为 "olleH"

🔍 内部原理：

  • 使用双指针技术：一个从头（left），一个从尾（right）
  • 交换 charAt(left) 和 charAt(right)
  • left++，right--
  • 直到 left >= right

步骤 3：获取结果（可选）

// 获取逆序后的字符串
String reversed = sb.toString();
System.out.println(reversed); // 输出: olleH

// 注意：sb 本身已被修改，仍为 "olleH"

完整示例代码

public class ReverseExample {
    public static void main(String[] args) {
        // 原始字符串
        String original = "Java Programming";
        
        // 1. 创建 StringBuilder
        StringBuilder sb = new StringBuilder(original);
        
        // 2. 调用 reverse() 逆序
        sb.reverse();
        
        // 3. 获取结果
        String reversed = sb.toString();
        
        // 输出
        System.out.println("原字符串: " + original);
        System.out.println("逆序后: " + reversed);
        // 输出:
        // 原字符串: Java Programming
        // 逆序后: gnimmargorP avaJ
    }
}

使用技巧

1. 链式调用（Fluent API）

String result = new StringBuilder("abc")
    .reverse()           // 逆序 -> "cba"
    .append("123")       // 追加 -> "cba123"
    .reverse()           // 再逆序 -> "321abc"
    .toString();
System.out.println(result); // 输出: 321abc

2. 只逆序部分内容

StringBuilder sb = new StringBuilder("Hello World");
// 先提取子串再逆序
String part = sb.substring(6); // "World"
String reversedPart = new StringBuilder(part).reverse().toString();
sb.replace(6, sb.length(), reversedPart); // 替换
System.out.println(sb); // 输出: Hello dlroW

3. 忽略大小写逆序（保持原格式）

String original = "AbCd";
StringBuilder sb = new StringBuilder(original.toLowerCase());
sb.reverse();
String reversed = sb.toString();
System.out.println(reversed); // 输出: dcba

常见错误

❌ 错误 1：误以为 String 有 reverse() 方法

String str = "abc";
str.reverse(); // 编译错误！String 没有 reverse() 方法

✅ 正确做法：

String reversed = new StringBuilder(str).reverse().toString();

❌ 错误 2：忘记 toString() 获取结果

StringBuilder sb = new StringBuilder("abc");
sb.reverse();
System.out.println(sb); // 虽然能输出，但类型是 StringBuilder
// 更规范的做法是 toString()

❌ 错误 3：在循环中重复创建 StringBuilder（性能差）

// 低效写法
for (int i = 0; i < 1000; i++) {
    String r = new StringBuilder("hello").reverse().toString();
}

✅ 优化：

// 如果是固定字符串，提前计算
String reversed = new StringBuilder("hello").reverse().toString();
for (int i = 0; i < 1000; i++) {
    System.out.println(reversed);
}

注意事项

  • ✅ reverse() 是原地修改，会改变原 StringBuilder 对象
  • ✅ 多次调用 reverse() 会来回反转： 
    sb.reverse().reverse(); // 回到原始顺序
  • ⚠️ StringBuilder 是线程不安全的，多线程环境下慎用
  • ✅ 支持 Unicode 字符（包括 emoji）： 
    System.out.println(new StringBuilder("👨‍👩‍👧‍👦").reverse());
// 输出可能不符合预期（因 emoji 是组合字符）

最佳实践与性能优化

1. ✅ 推荐：使用 StringBuilder.reverse()

public static String reverseString(String str) {
    return new StringBuilder(str).reverse().toString();
}

✅ 优点：代码简洁、性能高、不易出错

2. ⚠️ 不推荐：手动字符交换（除非特殊需求）

// 虽然可行，但没必要
public static String reverseManual(String str) {
    char[] chars = str.toCharArray();
    int left = 0, right = chars.length - 1;
    while (left < right) {
        char temp = chars[left];
        chars[left] = chars[right];
        chars[right] = temp;
        left++;
        right--;
    }
    return new String(chars);
}

3. ✅ 性能优化建议

场景 优化策略
小字符串 直接使用 new StringBuilder(str).reverse()
大字符串 预设容量 new StringBuilder(1024)
频繁逆序 缓存结果，避免重复计算
只读操作 考虑是否真的需要逆序，或可用其他算法替代

4. 🚀 高性能场景：复用 StringBuilder

// 避免频繁创建对象
private static final StringBuilder REVERSE_SB = new StringBuilder();

public static String reverseWithReuse(String str) {
    REVERSE_SB.setLength(0); // 清空内容
    REVERSE_SB.append(str);
    return REVERSE_SB.reverse().toString();
}

⚠️ 注意：线程安全问题，多线程需加锁或使用 ThreadLocal

扩展：处理特殊字符

处理 Unicode 组合字符（如 emoji）

// 普通 reverse() 可能破坏 emoji
String emoji = "👍🎉";
String reversed = new StringBuilder(emoji).reverse().toString();
System.out.println(reversed); // 可能显示异常

// 更安全的方式：按 code point 操作
public static String reverseUnicode(String str) {
    StringBuilder sb = new StringBuilder();
    for (int i = str.codePointCount(0, str.length()) - 1; i >= 0; i--) {
        int cp = str.codePointBefore(i + 1);
        sb.appendCodePoint(cp);
    }
    return sb.toString();
}

总结

项目 说明
核心方法 StringBuilder.reverse()
操作类型 原地修改（in-place）
时间复杂度 O(n)
空间复杂度 O(1) 额外空间（不计结果）
推荐做法 new StringBuilder(str).reverse().toString()
常见错误 误用 String.reverse()、忽略 toString()
性能提示 复用对象、预设容量、避免重复创建

✅ 一句话掌握：
使用 new StringBuilder(原字符串).reverse().toString() 是 Java 中实现字符串逆序最简洁、最高效的方式。记住它是原地修改，且 StringBuilder 本身不保留原始字符串。