Java案例如何实现字符串反转？

本文目录导读：

1. 使用StringBuilder/StringBuffer（最推荐）
2. 手动实现（循环遍历）
3. 使用递归实现
4. 使用栈（Stack）
5. Java 8+ 流式操作
6. 完整示例：多种方法对比
7. 性能建议

我来介绍几种Java中实现字符串反转的方法：

使用StringBuilder/StringBuffer（最推荐）

public class StringReverseExample {
    public static void main(String[] args) {
        String str = "Hello World";
        // 方法1: 使用StringBuilder
        String reversed1 = new StringBuilder(str).reverse().toString();
        System.out.println("StringBuilder反转: " + reversed1);  // dlroW olleH
        // 方法2: 使用StringBuffer（线程安全，但性能稍差）
        String reversed2 = new StringBuffer(str).reverse().toString();
        System.out.println("StringBuffer反转: " + reversed2);  // dlroW olleH
    }
}

手动实现（循环遍历）

public class ManualReverseExample {
    // 方法1: 字符数组方式
    public static String reverseByCharArray(String str) {
        char[] charArray = str.toCharArray();
        int left = 0;
        int right = charArray.length - 1;
        while (left < right) {
            // 交换字符
            char temp = charArray[left];
            charArray[left] = charArray[right];
            charArray[right] = temp;
            left++;
            right--;
        }
        return new String(charArray);
    }
    // 方法2: 从后往前遍历
    public static String reverseByLoop(String str) {
        StringBuilder result = new StringBuilder();
        for (int i = str.length() - 1; i >= 0; i--) {
            result.append(str.charAt(i));
        }
        return result.toString();
    }
    public static void main(String[] args) {
        String str = "Java";
        System.out.println(reverseByCharArray(str));  // avaJ
        System.out.println(reverseByLoop(str));       // avaJ
    }
}

使用递归实现

public class RecursiveReverseExample {
    public static String reverseRecursively(String str) {
        // 基本情况：空字符串或单个字符
        if (str == null || str.length() <= 1) {
            return str;
        }
        // 递归：最后一个字符 + 剩余字符串的反转
        return str.charAt(str.length() - 1) 
               + reverseRecursively(str.substring(0, str.length() - 1));
    }
    public static void main(String[] args) {
        String str = "Recursive";
        System.out.println(reverseRecursively(str));  // evisruceR
    }
}

使用栈（Stack）

import java.util.Stack;
public class StackReverseExample {
    public static String reverseByStack(String str) {
        Stack<Character> stack = new Stack<>();
        // 将每个字符压入栈
        for (char c : str.toCharArray()) {
            stack.push(c);
        }
        // 弹出栈中字符，实现反转
        StringBuilder result = new StringBuilder();
        while (!stack.isEmpty()) {
            result.append(stack.pop());
        }
        return result.toString();
    }
    public static void main(String[] args) {
        String str = "Stack";
        System.out.println(reverseByStack(str));  // kcatS
    }
}

Java 8+ 流式操作

import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class StreamReverseExample {
    public static String reverseByStream(String str) {
        return IntStream.range(0, str.length())
                .mapToObj(i -> str.charAt(str.length() - 1 - i))
                .map(String::valueOf)
                .collect(Collectors.joining());
    }
    public static void main(String[] args) {
        String str = "Stream";
        System.out.println(reverseByStream(str));  // maertS
    }
}

完整示例：多种方法对比

public class StringReverseDemo {
    public static void main(String[] args) {
        String str = "Hello Java World!";
        System.out.println("原始字符串: " + str);
        System.out.println("-----------------------------");
        // 方法1: StringBuilder
        System.out.println("1. StringBuilder: " + 
                          new StringBuilder(str).reverse());
        // 方法2: 字符数组交换
        System.out.println("2. 字符数组交换: " + 
                          reverseByCharArray(str));
        // 方法3: 循环遍历
        System.out.println("3. 循环遍历: " + 
                          reverseByLoop(str));
        // 方法4: 递归（不推荐长字符串，会有栈溢出风险）
        System.out.println("4. 递归: " + 
                          reverseRecursively(str));
        // 方法5: 使用Stream
        System.out.println("5. Stream: " + 
                          reverseByStream(str));
    }
    private static String reverseByCharArray(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);
    }
    private static String reverseByLoop(String str) {
        StringBuilder sb = new StringBuilder();
        for (int i = str.length() - 1; i >= 0; i--) {
            sb.append(str.charAt(i));
        }
        return sb.toString();
    }
    private static String reverseRecursively(String str) {
        if (str.length() <= 1) return str;
        return reverseRecursively(str.substring(1)) + str.charAt(0);
    }
    private static String reverseByStream(String str) {
        return IntStream.range(0, str.length())
                .mapToObj(i -> str.charAt(str.length() - 1 - i))
                .map(String::valueOf)
                .collect(Collectors.joining());
    }
}

性能建议

• 最推荐：StringBuilder.reverse() - 简单、高效
• 中等长度字符串：字符数组交换法
• 避免使用：递归方法处理长字符串（栈溢出风险）
• 多线程环境：StringBuffer.reverse()（线程安全）

选择哪种方法取决于你的具体需求：代码简洁性、性能要求、是否线程安全等。