java 反转字符串的五种方式以及性能比较。

1.使用StringBuilder或StringBuffer的reverse()方法

String str = "Hello word";
//使用 StringBuilder 类的 reverse() 方法对字符串进行反转
StringBuilder stringBuilder = new StringBuilder(str);
StringBuilder reverseStr = stringBuilder.reverse();
System.out.println(reverseStr);
        
//使用 StringBuffer 类的 reverse() 方法对字符串进行反转
StringBuffer stringBuffer = new StringBuffer(str);
StringBuffer reverseStr1 = stringBuffer.reverse();
System.out.println(reverseStr1);

 2.使用字符数组

String str = "Hello word";
byte[] oldBytes = str.getBytes();
byte[] newBytes = new byte[oldBytes.length];
for (int i = 0; i < oldBytes.length; i++) {
     //将原字节数组中的每个字节进行反转
     newBytes[oldBytes.length-1-i] = oldBytes[i];
}
System.out.println(new String(newBytes));

3.使用递归

    
public static String reverseString(String str) {
     // 递归结束条件
     if(str.isEmpty()) return str;
     // 在递归调用中，str.substring(1) 表示去掉字符串的第一个字符后剩下的部分。
     // reverseString(str.substring(1)) 对这部分字符串递归调用反转函数，从而得到反转后的字符串。
     // str.charAt(0) 表示字符串的第一个字符。
     // + 运算符用于将这个字符连接到反转后的字符串的末尾。
     // 通过这种方式，每次递归调用都会将原始字符串的第一个字符移动到最后一个位置。
     return reverseString(str.substring(1)) + str.charAt(0);
}

public static void main(String[] args) {
     System.out.println(reverseString("hello word"));
}

 4.使用栈

 /**
     * reverseString方法用于反转字符串
     * 创建了一个Stack对象，用于存储字符。
     * 将输入的字符串转换为字符数组。
     * 遍历字符数组，将每个字符入栈。
     * 创建一个StringBuilder对象，用于构建反转后的字符串。
     * 当栈不为空时，循环从栈中弹出字符，并添加到StringBuilder中。
     * */

    public static String reverseString(String str){
        Stack<Character> stack  = new Stack<>();
        char[] charArray = str.toCharArray();
        for (char c : charArray) {
            stack.push(c);
        }
        StringBuilder reverseStr = new StringBuilder();
        while (!stack.isEmpty()){
            reverseStr.append(stack.pop());
        }
        return reverseStr.toString();
    }


    public static void main(String[] args) {
        String s = reverseString("hello world");
        System.out.println(s);
    }

5.使用双指针

public static String reverse6(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);
}

性能比较:

总结：经过大量测试 StringBuilder StringBuffer 递归 字符数组 的性能差距不大；使用栈，效率最低；而性能断层最高的是双指针反转。