JAVA多種方法實現字符串反轉

package cn.daycode.leetcode;
 
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Stack;
 
public class Reverses {
    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {
        Method[] methods = Reverses.class.getDeclaredMethods();
        String s1 = "thgir";
        String s2 = "aabbcc";
        int i = 1;
        System.out.println("測試字符串為："+s1+","+s2);
        // 反射取出Reverses類中所有名字帶reverse的方法，並依次調用
        for (Method m : methods){
            if (m.getName().contains("reverse")){
                System.out.print(i+++".");
                System.out.print("調用瞭"+m.getName()+"方法，");
                System.out.print("逆序後的結果為："+m.invoke(new Reverses(),s1));
                System.out.println(","+m.invoke(new Reverses(),s2));
            }
        }
    }
 
    // 方法A1：使用StringBuffer的reverse方法
    private static String reverseA1(String s){
        return new StringBuffer(s).reverse().toString();
    }
 
    // 方法A2：使用StringBuilder的reverse方法
    private static String reverseA2(String s){
        return new StringBuilder(s).reverse().toString();
    }
 
    // 方法B1：將字符串轉變為字符數組，遍歷數組的一半，將頭尾開始對應的字符交換
    private static String reverseB1(String s){
        char[] chars = s.toCharArray();
        int length = chars.length-1;
 
        for (int i = 0; i <= length/2; i++) {
            if(chars[i] != chars[length - i]) {
                chars[i] = (char) (chars[i] ^ chars[length - i]);
                chars[length - i] = (char) (chars[i] ^ chars[length - i]);
                chars[i] = (char) (chars[i] ^ chars[length - i]);
            }
        }
 
        return String.valueOf(chars);
    }
 
    // 方法B2：逆向遍歷s，正序拼接出一個新的字符串
    private static String reverseB2(String s){
        StringBuffer sb = new StringBuffer("");
 
        for (int i = s.length()-1; i >= 0 ; i--) {
            sb.append(s.charAt(i));
        }
 
        return sb.toString();
    }
 
    // 方法B3：正向遍歷s，將取出的字符拼接形成中間字符串，將中間字符串拼接在下一個字符的後面
    private static String reverseB3(String s){
        String str = "";
 
        for (int i = 0; i < s.length() ; i++) {
            str = s.charAt(i) + str;
        }
 
        return str;
    }
 
    // 方法C1：遞歸，將字符串二分後前後交換，遞歸結束條件為字符串長度小於等於1
    private static String reverseC1(String s){
        if(s.length() <= 1){
            return s;
        }
        String l = s.substring(0, s.length()/2);
        String r = s.substring(s.length()/2, s.length());
        return reverseC1(r)+reverseC1(l);
    }
 
    // 方法C2：遞歸，思路同B3，結束條件是長度為1
    private static String reverseC2(String s){
        if (s.length() <= 1){
            return s;
        }
        return  reverseC2(s.substring(1))+s.charAt(0);
    }
 
    // 方法D1：利用棧stack先進後出的原理實現
    private static String reverseD1(String s){
        char[] str = s.toCharArray();
        Stack<Character> stack = new Stack<Character>();
        for (int i = 0; i < str.length; i++)
            stack.push(str[i]);
 
        StringBuffer sb = new StringBuffer("");
        for (int i = 0; i < str.length; i++)
            sb.append(stack.pop());
 
        return sb.toString();
    }
 
    // 方法B4：從首位兩邊同時遍歷，交換首位下標位置的字符
    private static String reverseB4(String s){
        char[] chars = s.toCharArray();
        int start = 0;
        int end = chars.length-1;
 
        while (start < end){
            if(chars[start] != chars[end]) {
                chars[start] = (char) (chars[start] ^ chars[end]);
                chars[end] = (char) (chars[start] ^ chars[end]);
                chars[start] = (char) (chars[start] ^ chars[end]);
            }
            start++;
            end--;
        }
 
        return String.valueOf(chars);
    }
 
}