JAVA多种方法实现字符串反转

本人自己思考+网络搜罗，分类整理了以下4类9种方法：

A类：使用JAVA原生方法

-A1：使用StringBuffer的reverse方法

-A2：使用StringBuilder的reverse方法

B类：遍历字符串（字符数组）实现

-B1：将字符串转变为字符数组，遍历该数组的一半，依次将头尾开始对应的字符交换

-B2：逆向遍历s，正序拼接出一个新的字符串

-B3：正向遍历s，将取出的字符拼接形成中间字符串，将中间字符串拼接在下一个字符的后面

-B4：从首位两边同时遍历，交换首位下标位置的字符（类似于B1）

C类：递归实现

-C1：将字符串二分后前后交换，递归结束条件为字符串长度小于等于1

-C2：思路同B3，结束条件是长度为1

D类：其他实现

-D1：利用栈stack先进后出的原理实现

有些方法有重复和相似的地方，以后如果搜集到不太相同的思路和解法，该帖我还会继续维护~欢迎收藏。如果各位有新的思路也欢迎交流，如果本人有写错的地方也欢迎指出。

最后补上代码和测试。

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

}

到此这篇关于JAVA多种方法实现字符串反转的文章就介绍到这了,更多相关JAVA字符串反转内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！