题目

将字符串数组[“1”, “2”, “3”, “4”, “5”, “6”]倒置，反转后的新数组为[“6”,“5”,“4”,“3”,“2”,“1”]。

算法实现

方法一

使用java中list的倒置函数，具体的实现如下：

    /**
     * 使用Collections.reverse来倒置数组
     *
     * @param strArray 原来的字符串数组
     * @return
     */
    public static String[] reverseArray1(String[] strArray) {
        //定一个新的数组
        String[] newArray = new String[strArray.length];
        List<String> list = new ArrayList<>();
        Collections.addAll(list, strArray);
        Collections.reverse(list);

        list.toArray(newArray);
        return newArray;
    }

方法二

先生成一个新的数组，然后将元素倒置放入新的数组，具体算法如下：

    /**
     * 倒置字符串数组
     *
     * @param strArray
     * @return
     */
    public static String[] reverseArray2(String[] strArray) {
        int len = strArray.length;
        //定义一个新的数组
        String[] newArray = new String[len];
        for (int i = 0; i < len; i++) {
            newArray[len - 1 - i] = strArray[i];
        }
        return newArray;
    }

方法三

先生成一个新的数组，然后将元素倒置放入新的数组，取数组中间位置，只遍历一半就可以完成赋值，具体代码如下：

    /**
     * 倒置字符串数组优化
     *
     * @param strArray
     * @return
     */
    public static String[] reverseArray3(String[] strArray) {
        int len = strArray.length;
        int mid = len/2;
        //定义一个新的数组
        String[] newArray = new String[len];
        for (int i = 0; i <= mid; i++) {
            newArray[i] = strArray[len-1 -i];
            newArray[len-1 - i] = strArray[i];
        }
        return newArray;
    }

方法四

先生成一个新的数组，然后将元素倒置放入新的数组，取数组中间位置，只遍历一半就可以完成赋值，在方法三的基础上将除法修改成移位运算，具体代码如下：

    /**
     * 倒置字符串数组优化,将除法替换成移位操作
     *
     * @param strArray
     * @return
     */
    public static String[] reverseArray4(String[] strArray) {
        int len = strArray.length;
        int mid = len >> 1;
        //定义一个新的数组
        String[] newArray = new String[len];
        for (int i = 0; i <= mid; i++) {
            newArray[i] = strArray[len - 1 - i];
            newArray[len - 1 - i] = strArray[i];
        }
        return newArray;
    }

方法五

使用用链表的方式，先把数组转换成用链表，然后倒序取值赋值给新数组，这个只是一种思路，具体代码如下：

    /**
     * 可以使用链表倒置的方式
     *
     * @param strArray
     * @return
     */
    public static String[] reverseArray5(String[] strArray) {
        LinkedList<String> linkedList = new LinkedList<>();
        Collections.addAll(linkedList, strArray);
        String[] newArray = new String[strArray.length];
        int loop = 0;
        while (!linkedList.isEmpty()) {
            newArray[loop] = linkedList.pollLast();
            loop++;
        }
        return newArray;
    }

代码以及效率测试

    /**
     * 打印数组
     *
     * @param strArray
     */
    public static void printArray(String[] strArray) {
        for (int i = 0, len = strArray.length; i < len; i++) {
            System.out.print(strArray[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] agrs) {
        String[] a = {"1", "2", "3", "4", "5", "6"};
        System.out.println("原来的数组为：");
        printArray(a);

        System.out.println("使用reverseArray1倒置后的数组为：");
        printArray(reverseArray1(a));

        System.out.println("使用reverseArray2倒置后的数组为：");
        printArray(reverseArray2(a));

        System.out.println("使用reverseArray3倒置后的数组为：");
        printArray(reverseArray3(a));

        System.out.println("使用reverseArray4倒置后的数组为：");
        printArray(reverseArray4(a));

        System.out.println("使用reverseArray5倒置后的数组为：");
        printArray(reverseArray5(a));

        System.out.println("-----下面针对耗时情况进行测试-----");
        int loopTimes = 1000000;
        long startTime1 = System.currentTimeMillis();
        for (int i = 0; i < loopTimes; i++) {
            reverseArray1(a);
        }
        System.out.println(loopTimes + "次循环，reverseArray1耗时：" + (System.currentTimeMillis() - startTime1) + "ms");

        long startTime2 = System.currentTimeMillis();
        for (int i = 0; i < loopTimes; i++) {
            reverseArray2(a);
        }
        System.out.println(loopTimes + "次循环，reverseArray2耗时：" + (System.currentTimeMillis() - startTime2) + "ms");

        long startTime3 = System.currentTimeMillis();
        for (int i = 0; i < loopTimes; i++) {
            reverseArray3(a);
        }
        System.out.println(loopTimes + "次循环，reverseArray3耗时：" + (System.currentTimeMillis() - startTime3) + "ms");

        long startTime4 = System.currentTimeMillis();
        for (int i = 0; i < loopTimes; i++) {
            reverseArray4(a);
        }
        System.out.println(loopTimes + "次循环，reverseArray4耗时：" + (System.currentTimeMillis() - startTime4) + "ms");

        long startTime5 = System.currentTimeMillis();
        for (int i = 0; i < loopTimes; i++) {
            reverseArray5(a);
        }
        System.out.println(loopTimes + "次循环，reverseArray5耗时：" + (System.currentTimeMillis() - startTime5) + "ms");
    }

打印结果

原来的数组为：
1 2 3 4 5 6 
使用reverseArray1倒置后的数组为：
6 5 4 3 2 1 
使用reverseArray2倒置后的数组为：
6 5 4 3 2 1 
使用reverseArray3倒置后的数组为：
6 5 4 3 2 1 
使用reverseArray4倒置后的数组为：
6 5 4 3 2 1 
使用reverseArray5倒置后的数组为：
6 5 4 3 2 1 
-----下面针对耗时情况进行测试-----
1000000次循环，reverseArray1耗时：526ms
1000000次循环，reverseArray2耗时：314ms
1000000次循环，reverseArray3耗时：194ms
1000000次循环，reverseArray4耗时：125ms
1000000次循环，reverseArray5耗时：217ms