Java中的字符串翻转

字符串翻转操作是再常见不过的问题了，C/C++中实际上就是操作字符数组，那么在Java中貌似不是直接就可以搞定的。

既然不能直接搞定，那么就是可以间接搞定，间接搞定意思就是先把原字符串转换为数组的形式，然后再前后做调换：

public class ReverseString {
    public static String swap1(String s) {
        byte[] byteArray = s.getBytes();
        byte[] reverseByteArray = new byte[s.length()];

        for (int i = 0; i < s.length(); i++) {
            reverseByteArray[i] = byteArray[s.length() - i - 1];
        }

        return new String(reverseByteArray);
    }

    public static String swap2(String s) {
        StringBuilder sb = new StringBuilder();
        sb.append(s);
        sb = sb.reverse();

        return sb.toString();
    }

    public static String swap3(String s) {
        char[] charArray = s.toCharArray();

        int i = 0;
        int j = s.length() - 1;

        while (i < j) {
            char c = charArray[i];
            charArray[i] = charArray[j];
            charArray[j] = c;
            i++;
            j--;
        }

        return new String(charArray);
    }

    public static void main(String[] args) {
        String s = new String("Reverse String");

        System.out.println(swap1(s));
        System.out.println(swap2(s));
        System.out.println(swap3(s));
    }

}

以上代码实现了三种翻转方式，其中第一种和第三种就是所说的转换为字符串然后做前后调换操作，这个与C/C++的思路是相同的。

第二种方法则是用StringBuilder直接调用reverse()方法，这个就简单多了，所以如果在实际应用中的话，至少从代码简洁量来考虑的话，还是会优先考虑StringBuilder直接调用reverse()方法的。

输出：

gnirtS esreveR
gnirtS esreveR
gnirtS esreveR