项目中我们会遇到需要将数组元素逆序输出的情形，可以有好几种方法完成这个需求：
1、方法一：逆序遍历数组元素并将元素放入新数组，分析时间复杂度是O(n),空间复杂度是o(n)

        for(Integer i = sqList.size() - 1; i >= 0; i --) {
            reversedArray.add(sqList.get(i));
        }

2、方法二：扫描数组元素的前半部分元素，将元素sqListi与其余后半部分对应的元素sqList[sqList.length - i - 1]进行交换,时间复杂度为O(n/2),不需要额外的空间

private static <T> void reverse(List<T> sqList) {
        if (sqList == null || sqList.size() < 1) {
            return;
        }
        T temp = null;
        Integer size = sqList.size();
        for (Integer j = 0; j < size >> 1; j++) {
            temp = sqList.get(j);
            sqList.set(j, sqList.get(size - j - 1));
            sqList.set(sqList.size() - j - 1, temp);
        }
}

3、方法三：Collections.reverse(sqList)，jdk内部源码实现如下，可以看到jdk源码的实现方式和方法二的思想是一致的，都是交换相应位置上的元素。所以Java中若数组元素逆序直接调用Collections.reverse方法即可。

  public static void reverse(List<?> list) {
        int size = list.size();
        if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) {
            for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--)
                swap(list, i, j);
        } else {
            // instead of using a raw type here, it's possible to capture
            // the wildcard but it will require a call to a supplementary
            // private method
            ListIterator fwd = list.listIterator();
            ListIterator rev = list.listIterator(size);
            for (int i=0, mid=list.size()>>1; i<mid; i++) {
                Object tmp = fwd.next();
                fwd.set(rev.previous());
                rev.set(tmp);
            }
        }
 }

4、方法四：将数组元素使用某一字符，如-，Join得到一个字符串，使用StringBuffer的reverse方法后再讲字符串以-分割得到数组即可。

public static String[] reverse(String[] array ){
        String str = String.join("-", array);
        StringBuffer buffer = new StringBuffer(str);
        String reverseStr = buffer.reverse().toString();
        String[] resultArray = reverseStr.split("-");
        return resultArray;
    }