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);
    }
 
}