Java字符串反转的10种方式

自定义revser() 传入字符串 返回字符串 要判断实参为null的特殊情况

 

方式一 双指针 while遍历 异或换位

    public static String reverse(String s){
        if (s==null) return s;

        char[] c = s.toCharArray();
        int l = 0, r = c.length-1;

        while (l < r) {
            c[l] ^= c[r];
            c[r] ^= c[l];
            c[l++] ^= c[r--];
        }

        return new String(c);
    }

 

方式二 单指针 for折半遍历 临时变量换位

    public static String reverse(String s){
        if (s==null) return s;

        char[] c = s.toCharArray();

        for (int i=0; i<c.length>>1; i++){
            char temp = c[c.length-1-i];
            c[c.length-1-i] = c[i];
            c[i] = temp;
        }

        return new String(c);
    }

 

方式三 递归 自定义recursion()和swap() 加法法则换位 符合面向对象程序设计

    public static String reverse(String s){
        if (s==null) return s;

        char[] c = s.toCharArray();

        int l = 0, r = c.length-1;
        recursion(c,l,r);

        return new String(c);
    }

    public static void recursion(char[] c, int l, int r){
        if (l>=r) return;

        swap(c,l,r);
        recursion(c, l+1, r-1);
    }

    public static void swap(char[] c, int l, int r){
        c[l] = (char) ( c[l] + c[r] );
        c[r] = (char) ( c[l] - c[r] );
        c[l] = (char) ( c[l] - c[r] );
    }

 

方式四  更符合面向过程设计 每一步都要实现 for只负责遍历 两个指针负责寻找 减法法则换位

    public static String reverse(String s){
        if (s==null) return s;
        
        char[] c = s.toCharArray();

        int l = 0;
        int r = c.length-1;
        int half = c.length/2;

        for (int i=0; i<half; i++) {
            c[l] = (char) ( c[l] - c[r] );
            c[r] = (char) ( c[r] + c[l] );
            c[l] = (char) ( c[r] - c[l] );
            l++;
            r--;
        }

        return new String(c);
    }

 

方式五 字符串拼接 正常的for遍历索引 新的字符拼接在最前面

    public static String reverse(String s){
        if (s==null) return s;

        String res = "";

        for (int i=0; i<s.length(); i++)
            res = s.charAt(i) + res;

        /*
        for (int i=s.length()-1; i>=0; i--)
            res += s.charAt(i);
        */

        return res;
    }

 

方式六 StringBuilder或StringBuffer的reverse()

    public static String reverse(String s){
        if (s==null) return s;

        return new StringBuilder(s).reverse().toString();

        // 构造方法不能接收字符数组 chars[]需要转换成String才可以
        /*char[] chars = s.toCharArray();
        return new StringBuilder(new String(chars).reverse().toString();
    }

 

方式七 临时数组 利用for循环将原数组中的字符 从后往前存放到临时数组中

    public static String reverse(String s){
        if (s == null) return s;

        char[] c = s.toCharArray();
        char[] res = new char[c.length];

        for (int i=0; i<c.length; i++)
            res[i] = c[c.length-1-i];

        return new String(res);
    }

 

方式八 集合工具类 只接收list  且Arrays.asList接收的基本数据类型需要转为包装类

public static String reverse(String s){
        if (s == null) return s;

        char[] c = s.toCharArray();

        Character[] res = new Character[c.length];
        for (int i=0; i<c.length; i++)
            res[i] = c[i];

        List<Character> list = Arrays.asList(res);
        Collections.reverse(list);

        for (int i=0; i<list.size(); i++)
            c[i] = list.get(i);

        return new String(c);
    }

 

方式九 栈反转  栈反转 利用Stack后进后出的特性 第一个遍历存入到栈中,第二个遍历从栈中取出

    public static String reverse(String s){
        if (s == null) return s;

        char[] c = s.toCharArray();
        Stack<Character> stack = new Stack<>();

        for(char temp : c)
            stack.push(temp);

        for (int i=0; i<c.length; i++)
            c[i] = stack.pop();

        return new String(c);
    }

 

方式十 链表的addFirst()实现先进后出 或 addLst实现后进先出

    public static String reverse(String s){
        if (s == null) return s;

        char[] c = s.toCharArray();
        LinkedList<Character> list = new LinkedList<>();

        for(Character t : c)
            list.addFirst(t);

        for(int j=0; j<c.length; j++)
            c[j] = list.removeFirst();

        return new String(c);
    }