Java 字符串反轉完整指南：五種實現方式性能對比與最佳實踐

核心思路

字符串在 Java 中不可變，反轉本質是創建新字符串。主要途徑：轉字符數組 → 反轉數組 → 構建新字符串。

五種實現方式代碼

1. StringBuilder.reverse() —— 首選（JDK 內建、最高效）

public static String reverse1(String str) {
    if (str == null) return null;
    return new StringBuilder(str).reverse().toString();
}

2. 字符數組雙指針交換 —— 手動實現、教學首選

public static String reverse2(String str) {
    if (str == null) return null;
    char[] arr = str.toCharArray();
    for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
        char tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    return new String(arr);
}

3. 遞歸實現 —— 僅教學演示，棧溢出風險

public static String reverse3(String str) {
    if (str == null || str.length() <= 1) return str;
    return reverse3(str.substring(1)) + str.charAt(0);
}

4. Java 8 Stream API —— 函數式風格

public static String reverse4(String str) {
    if (str == null) return null;
    return str.chars()
              .mapToObj(c -> (char) c)
              .reduce("", (a, b) -> b + a, (a, b) -> b + a);
}

5. ByteBuffer / NIO —— 異域風格，無實際優勢

public static String reverse5(String str) {
    if (str == null) return null;
    ByteBuffer bb = ByteBuffer.wrap(str.getBytes(StandardCharsets.UTF_8));
    byte[] bytes = new byte[bb.remaining()];
    for (int i = bytes.length - 1; i >= 0; i--) {
        bytes[i] = bb.get();
    }
    return new String(bytes, StandardCharsets.UTF_8);
}

性能基準測試 (JMH 風格)

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class StringReverseBenchmark {
    @Param({"10", "100", "1000", "10000"})
    int length;

    String input;

    @Setup
    public void setup() {
        input = "a".repeat(length); // Java 11+
    }

    @Benchmark
    public void stringBuilder() { new StringBuilder(input).reverse(); }

    @Benchmark
    public void charArraySwap() {
        char[] arr = input.toCharArray();
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            char t = arr[i]; arr[i] = arr[j]; arr[j] = t;
        }
    }

    @Benchmark
    public void streamApi() {
        input.chars().mapToObj(c -> (char) c).reduce("", (a, b) -> b + a, (a, b) -> b + a);
    }
}

典型測試結果 (輸出時間 ns/op)

關鍵結論

• ✅ 生產首選：new StringBuilder(str).reverse().toString() —— 代碼最簡、JDK 優化最充分、性能最穩健。
• ✅ 面試/教學手寫：字符數組雙指針交換 —— 展示原地反轉邏輯、O(1) 額外空間（不計輸出）、無庫依賴。
• ❌ 避免：遞歸（棧溢出）、+ 拼接（O(n²)）、Stream API（物件創建開銷巨大）。
• 💡 補充：StringBuffer 線程安全但較慢，單線程用 StringBuilder。

完整工具類

public final class StringUtils {
    private StringUtils() {}

    public static String reverse(String str) {
        if (str == null || str.length() <= 1) return str;
        return new StringBuilder(str).reverse().toString();
    }

    /** 指定區間反轉 [start, end) */
    public static String reverseRange(String str, int start, int end) {
        if (str == null) return null;
        int len = str.length();
        start = Math.max(0, Math.min(start, len));
        end = Math.max(start, Math.min(end, len));
        char[] arr = str.toCharArray();
        for (int i = start, j = end - 1; i < j; i++, j--) {
            char t = arr[i]; arr[i] = arr[j]; arr[j] = t;
        }
        return new String(arr);
    }
}

總結

Java 字符串反轉，99% 場景用 StringBuilder.reverse()。面試手寫雙指針交換。理解不可變性、字符數組操作、性能差異，才是核心收穫。