public class StringReverse {

    // 方法1: 使用 StringBuilder 的 reverse() 方法 (推荐，高效简洁)
    public static String reverseStringStringBuilder(String str) {
        if (str == null) {
            return null; // 处理 null 输入
        }
        return new StringBuilder(str).reverse().toString();
    }

    // 方法2: 迭代方式 (更易理解，但效率略低于 StringBuilder)
    public static String reverseStringIterative(String str) {
        if (str == null) {
            return null; // 处理 null 输入
        }
        String reversedStr = ""; // 初始化空字符串用于存储反转后的字符串
        for (int i = str.length() - 1; i >= 0; i--) {
            reversedStr += str.charAt(i); // 从后向前遍历，逐个字符添加到新字符串
        }
        return reversedStr;
    }

    // 方法3: 使用字符数组 (思路类似迭代，但操作字符数组)
    public static String reverseStringCharArray(String str) {
        if (str == null) {
            return null; // 处理 null 输入
        }
        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); // 将字符数组转换为字符串
    }

    public static void main(String[] args) {
        String inputString = "abcd";
        String reversedString1 = reverseStringStringBuilder(inputString);
        String reversedString2 = reverseStringIterative(inputString);
        String reversedString3 = reverseStringCharArray(inputString);

        System.out.println("原始字符串: " + inputString);
        System.out.println("使用 StringBuilder 反转: " + reversedString1); // 输出: dcba
        System.out.println("迭代方式反转: " + reversedString2);       // 输出: dcba
        System.out.println("字符数组方式反转: " + reversedString3);     // 输出: dcba

        String emptyString = "";
        System.out.println("\n原始字符串 (空字符串): " + emptyString);
        System.out.println("使用 StringBuilder 反转: " + reverseStringStringBuilder(emptyString)); // 输出: (空字符串)

        String nullString = null;
        System.out.println("\n原始字符串 (null): " + nullString);
        System.out.println("使用 StringBuilder 反转: " + reverseStringStringBuilder(nullString));   // 输出: null
    }
}

代码解释和方法比较:

1.
reverseStringStringBuilder(String str) (推荐方法):

• 原理: 利用 StringBuilder 类提供的 reverse() 方法。StringBuilder 是可变的字符串，reverse() 方法直接在 StringBuilder 对象上进行反转操作，效率很高。
• 步骤:if (str == null) { return null; }: 首先处理 null 输入，如果输入字符串为 null，则直接返回 null，避免 NullPointerException。new StringBuilder(str): 创建一个新的 StringBuilder 对象，并将输入的字符串 str 作为初始内容。.reverse(): 调用 StringBuilder 对象的 reverse() 方法，该方法会直接反转 StringBuilder 对象内部的字符序列。.toString(): 将反转后的 StringBuilder 对象转换回 String 对象，并返回。
• 优点: 最简洁、最有效率 的方法。StringBuilder 的 reverse() 方法是专门为字符串反转设计的，性能最佳。
• 缺点: 代码相对较少，可能不太直观地展示反转的逻辑过程。

2. reverseStringIterative(String str) (迭代方式):

• 原理: 通过循环从字符串的末尾开始向前遍历，逐个字符添加到新的字符串中，从而实现反转。
• 步骤:if (str == null) { return null; }: 处理 null 输入。String reversedStr = "";: 初始化一个空字符串 reversedStr，用于存储反转后的字符串。for (int i = str.length() - 1; i >= 0; i--) { ... }: 使用 for 循环，从字符串 str 的最后一个字符 (索引 str.length() - 1) 遍历到第一个字符 (索引 0)。reversedStr += str.charAt(i);: 在循环中，使用 str.charAt(i) 获取当前索引 i 处的字符，并使用 += 运算符将其追加到 reversedStr 的末尾。 注意： 在循环中使用 += 运算符拼接 String 在性能上不如 StringBuilder，因为每次 += 都会创建一个新的 String 对象。这里为了代码的易理解性使用了 String 拼接。return reversedStr;: 循环结束后，reversedStr 就包含了反转后的字符串，将其返回。
• 优点: 代码逻辑清晰易懂，直接展示了字符串反转的迭代过程。
• 缺点: 效率相对较低，尤其是在处理长字符串时，由于 String 的不可变性，每次 += 操作都会创建新的 String 对象，导致性能开销较大。

3. reverseStringCharArray(String str) (字符数组方式):

• 原理: 将字符串转换为字符数组，然后使用双指针（左右指针）从数组两端向中间交换字符，实现数组的反转，最后将反转后的字符数组转换回字符串。
• 步骤:if (str == null) { return null; }: 处理 null 输入。char[] charArray = str.toCharArray();: 使用 str.toCharArray() 将输入字符串 str 转换为字符数组 charArray。int left = 0; int right = charArray.length - 1;: 初始化左右指针 left 和 right，分别指向字符数组的起始和末尾位置。while (left < right) { ... }: 使用 while 循环，当左指针 left 小于右指针 right 时，循环继续。交换字符:
• java复制代码
• char temp = charArray[left]; charArray[left] = charArray[right]; charArray[right] = temp; 在循环中，交换 charArray[left] 和 charArray[right] 的值，实现字符交换。
• 移动指针:
• java复制代码
• left++; right--; 将左指针 left 向右移动一位，将右指针 right 向左移动一位，逐步向数组中心靠近。
• return new String(charArray);: 循环结束后，字符数组 charArray 就被反转了，使用 new String(charArray) 将字符数组转换为 String 对象并返回。
• 优点: 思路清晰，使用了常见的双指针交换方法，展示了数组反转的逻辑。 效率比迭代拼接字符串的方式高，因为直接操作字符数组，避免了 String 的频繁创建。
• 缺点: 代码相对 StringBuilder 方式稍显复杂。

性能比较:

• StringBuilder.reverse() (方法1): 性能最佳，时间复杂度为 O(n)，且 StringBuilder 内部操作效率高。
• 字符数组方式 (方法3): 性能次之，时间复杂度也为 O(n)，直接操作字符数组比 String 拼接效率高。
• 迭代方式 (方法2): 性能相对较差，尤其是在处理长字符串时，由于 String 的不可变性，每次 += 操作都会创建新的 String 对象，时间复杂度接近 O(n^2) 在某些情况下。

推荐使用
reverseStringStringBuilder(String str) 方法，因为它最简洁、高效，并且是 Java 官方推荐的反转字符串的方式。 如果更注重代码的易理解性，或者需要展示字符串反转的逻辑过程，可以选择迭代方式或字符数组方式。