关于字符串反转和数组反转的问题

关于反转这个问题,在晚上查了些资料,有很多非常不错的思想,要熟练的掌握这些思想,现在把这些总结如下:

字符串反转:

import java.util.Stack;

public class StringInverse {
    public static void main(String[] args) {
        System.out.println(reverse7("abcde"));
    }
    //方式一
    public static String reverse1(String s) {
        int length = s.length();
        if (length <= 1)
            return s;
        String left = s.substring(0, length / 2);//ab
        String right = s.substring(length / 2, length);//de
        return reverse1(right) + reverse1(left);//此处用到了递归!!!
    }
    //方式二
    public static String reverse2(String s) {
        int length = s.length();
        String reverse = "";//空字符串
        for (int i = 0; i < length; i++)
            reverse = s.charAt(i) + reverse;//reverse放在后面
        //charAt()返回的是一个char
        return reverse;
    }
    //方式三
    public static String reverse3(String s) {
        char[] array = s.toCharArray();
        String reverse = "";//空字符串
        for (int i = array.length - 1; i >= 0; i--)
            reverse += array[i];
        //reverse放在前面
        return reverse;
    }
    //方式四
    public static String reverse4(String s) {
        //JDK提供的API
        return new StringBuffer(s).reverse().toString();
    }
    //方式五
    public static String reverse5(String str) {
        //把字符串编程一个字符数组,利用数组的下标来更换字符的位置.
        char[] s = str.toCharArray();
        //返回值是char[] toCharArray()将此字符串转换为一个新的字符数组。
        int n = s.length - 1;
        int halfLength = n / 2;
        for (int i = 0; i <= halfLength; i++) {
            char temp = s[i];
            s[i] = s[n - i];
            s[n - i] = temp;
        }
        //利用String(char[])这个构造方法.
        return new String(s);
    }
    //方式六
    public static String reverse6(String s) {
        char[] str = s.toCharArray();
        int begin = 0;
        int end = s.length() - 1;
        while (begin < end) {
            //同一个数字或者字符串等异或两次还是这个对象.下边的操作就是对str[begin]和str[end]调换位置.
            str[begin] = (char) (str[begin] ^ str[end]);
            str[end] = (char) (str[begin] ^ str[end]);
            str[begin] = (char) (str[end] ^ str[begin]);
            begin++;
            end--;
        }
        return new String(str);
    }
    //方式七
    public static String reverse7(String s) {
        char[] str = s.toCharArray();
        Stack<Character> stack = new Stack<Character>();
        for (int i = 0; i < str.length; i++)
            stack.push(str[i]);
        String reversed = "";
        for (int i = 0; i < str.length; i++)
            reversed += stack.pop();
        //pop()移除堆栈顶部的对象，并作为此函数的值返回该对象。
        return reversed;
    }
}

数组的反转(我就找到一个比较经典的):

高大上的数组转换位置.....

import java.lang.reflect.Array;

public class ArrayInverse {

    public static void main(String[] args) {
        int[] myarray = { 1, 2, 3 };
        int[] newarray = invertArray(myarray);

        for (int i = 0; i < newarray.length; i++) {
            System.out.print(newarray[i] + " ");
        }
    }

    /**
     * 反转数组
     * 
     */
    public static <T> T invertArray(T array) {
        int len = Array.getLength(array);
        // 获取泛型的类型(既数组的类型)
        Class<?> classz = array.getClass().getComponentType();
        // newInstance(Class<?> componentType,int length)
        // 创建一个具有指定的组件类型和长度的新数组。调用此方法等效于创建如下数组：
        Object dest = Array.newInstance(classz, len);

        // arraycopy()从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
        System.arraycopy(array, 0, dest, 0, len);

        Object temp;

        for (int i = 0; i < (len / 2); i++) {
            temp = Array.get(dest, i);// get(Object array, int index)返回指定数组对象中索引组件的值。
            Array.set(dest, i, Array.get(dest, len - i - 1));
            Array.set(dest, len - i - 1, temp);
        }
        return (T) dest;
    }
}