Java字符串反转的三种方法解析

结论：Java中反转字符串最高效且简洁的方法是使用StringBuilder的reverse方法。此外，还可通过char数组对撞交换和递归方式实现。1. StringBuilder的reverse方法性能最佳，适用于大多数场景，代码简洁高效；2. char数组对撞交换通过两个指针逐步交换字符实现反转，更贴近底层原理；3. 递归方式虽然优雅但性能较差，适合展示对递归的理解。对于包含Unicode字符的字符串，StringBuilder已能正确处理；若需反转部分内容，可通过substring截取、reverse反转、replace替换实现；在多线程环境下，可使用StringBuffer或加锁机制确保线程安全。

直接上结论：Java中反转字符串，StringBuilder的reverse方法效率最高，也最简洁。当然，如果面试官问你，最好能把其他方法也说出来，体现你的知识广度。

StringBuilder的reverse方法，char数组对撞交换，以及递归方式。

如何使用StringBuilder反转字符串？

StringBuilder类天生就是为字符串操作而生的，reverse() 方法简直是为反转字符串量身定制的。

public class StringReverse {
    public static void main(String[] args) {
        String str = "abcdefg";
        StringBuilder sb = new StringBuilder(str);
        String reversedStr = sb.reverse().toString();
        System.out.println("原始字符串: " + str);
        System.out.println("反转后的字符串: " + reversedStr);
    }
}

这段代码够简单吧？先创建一个StringBuilder对象，把要反转的字符串放进去，然后调用reverse()，最后再转换回String。性能嘛，杠杠的。

char数组对撞交换反转字符串

这种方法稍微底层一点，但能让你更了解字符串的内部结构。其实，字符串在内存里可以看成是char类型的数组。

public class StringReverse {
    public static void main(String[] args) {
        String str = "abcdefg";
        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--;
        }

        String reversedStr = new String(charArray);
        System.out.println("原始字符串: " + str);
        System.out.println("反转后的字符串: " + reversedStr);
    }
}

这个方法的核心思想是，用两个指针，一个指向数组的开头（left），一个指向数组的结尾（right），然后不断地交换这两个指针指向的字符，直到left和right相遇。

递归方式反转字符串

递归，听起来就有点高大上。虽然用递归反转字符串在性能上可能不是最优的，但它可以展示你对递归的理解。

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

    public static void main(String[] args) {
        String str = "abcdefg";
        String reversedStr = reverseStringRecursive(str);
        System.out.println("原始字符串: " + str);
        System.out.println("反转后的字符串: " + reversedStr);
    }
}

递归的思路是，每次把字符串分成两部分：第一个字符和剩下的部分。然后，递归地反转剩下的部分，最后把第一个字符加到反转后的字符串的末尾。

哪种反转方式性能最好？

毫无疑问，StringBuilder的reverse()方法在大多数情况下都是性能最佳的选择。因为它直接在StringBuilder对象上进行操作，避免了不必要的内存分配和复制。char数组对撞交换也不错，但需要手动管理指针。递归方法虽然优雅，但由于函数调用的开销，性能相对较差，特别是对于长字符串。

反转字符串时，如何处理包含Unicode字符的字符串？

当字符串包含Unicode字符（例如，中文、日文、Emoji表情等）时，直接使用reverse()方法或char数组交换可能不会得到正确的结果。因为有些Unicode字符由两个char组成（增补字符，Surrogate Pair）。

public class StringReverse {
    public static String reverseStringWithUnicode(String str) {
        return new StringBuilder(str).reverse().toString(); // StringBuilder 已经可以正确处理 Unicode
    }

    public static void main(String[] args) {
        String str = "Hello 你好 ?";
        String reversedStr = reverseStringWithUnicode(str);
        System.out.println("原始字符串: " + str);
        System.out.println("反转后的字符串: " + reversedStr);
    }
}

StringBuilder的reverse方法已经做了处理，可以正确反转Unicode字符。

除了反转整个字符串，如何反转字符串中的部分内容？

有时候，我们可能只需要反转字符串中的一部分，而不是整个字符串。比如，只反转字符串中的某个单词，或者反转字符串中从某个位置开始到结束的部分。

public class StringReverse {
    public static String reversePartialString(String str, int start, int end) {
        if (str == null || start < 0 || end > str.length() || start >= end) {
            return str; // 边界条件判断
        }
        StringBuilder sb = new StringBuilder(str);
        StringBuilder sub = new StringBuilder(sb.substring(start, end));
        sub.reverse();
        sb.replace(start, end, sub.toString());
        return sb.toString();
    }

    public static void main(String[] args) {
        String str = "Hello World";
        String reversedStr = reversePartialString(str, 0, 5); // 反转 "Hello"
        System.out.println("原始字符串: " + str);
        System.out.println("反转后的字符串: " + reversedStr); // 输出 olleH World
    }
}

这段代码中，reversePartialString 方法接受三个参数：要反转的字符串，起始位置和结束位置。它首先创建一个StringBuilder对象，然后使用substring方法截取需要反转的部分，接着反转这部分内容，并使用replace方法替换原来的字符串。

在多线程环境下，如何安全地反转字符串？

在多线程环境下，如果多个线程同时修改同一个字符串，可能会导致数据竞争和不一致的结果。为了保证线程安全，可以使用以下方法：

1. 使用线程安全的StringBuilder： StringBuffer是线程安全的StringBuilder，可以在多线程环境下使用。
2. 使用锁： 使用synchronized关键字或Lock对象来保护字符串的反转操作。
3. 使用不可变对象： 将字符串转换为不可变对象，例如使用Guava库的ImmutableList或ImmutableMap。

public class StringReverse {
    public static String reverseStringThreadSafe(String str) {
        StringBuffer sb = new StringBuffer(str); // StringBuffer 是线程安全的
        return sb.reverse().toString();
    }

    public static void main(String[] args) {
        String str = "abcdefg";
        String reversedStr = reverseStringThreadSafe(str);
        System.out.println("原始字符串: " + str);
        System.out.println("反转后的字符串: " + reversedStr);
    }
}