有两种方法可以解决这个问题:

1. 在空格中反转数组。

步骤1。交换开始和结束索引处的元素。

步骤2。递增开始索引，递减结束索引。

步骤3。重复步骤1和步骤2，直到开始索引<结束索引

此时，时间复杂度为O(n)空间复杂度为O(1)

在空间中反转数组的示例代码如下:

public static int[] reverseAnArrayInSpace(int[] array) {
    int startIndex = 0;
    int endIndex = array.length - 1;
    while(startIndex < endIndex) {
        int temp = array[endIndex];
        array[endIndex] = array[startIndex];
        array[startIndex] = temp;
        startIndex++;
        endIndex--;
    }
    return array;
}

2. 使用辅助数组反转数组。

步骤1。创建一个大小等于给定数组的新数组。

步骤2。元素从开始索引开始插入到新数组中 给定数组，从结束索引开始。

因此，时间复杂度为O(n)空间复杂度为O(n)

用辅助数组反转数组的示例代码如下:

public static int[] reverseAnArrayWithAuxiliaryArray(int[] array) {
    int[] reversedArray = new int[array.length];
    for(int index = 0; index < array.length; index++) {
        reversedArray[index] = array[array.length - index -1]; 
    }
    return reversedArray;
}

此外，我们可以使用Java中的Collections API来实现这一点。

Collections API在内部使用相同的反向空间方法。

使用Collections API的示例代码如下:

public static Integer[] reverseAnArrayWithCollections(Integer[] array) {
    List<Integer> arrayList = Arrays.asList(array);
    Collections.reverse(arrayList);
    return arrayList.toArray(array);
}

public class TryReverse {
    public static void main(String[] args) {        
        int [] array = {2,3,4,5,6,7,8,9};       
        reverse(array);
        for(int i=0; i<array.length; ++i)
            System.out.print(array[i] + " ");
    }
    public static void reverse (int [] array){
        for(int start=0, end=array.length-1; start<=end; start++, end--){
            int aux = array[start];
            array[start]=array[end];
            array[end]=aux;
        }
    }
}

另一种反向数组的方法

public static int []reversing(int[] array){
    int arraysize = array.length;
    int[] reverse = new int [arraysize+1];
    for(int i=1; i <= arraysize ; i++){
        int dec= arraysize -i;
        reverse[i] = array[dec];
    }
    return reverse;
}

番石榴

使用谷歌Guava库:

Collections.reverse(Ints.asList(array));

一种无需额外库、导入或静态引用即可进行反向操作的简便方法。

int[] a = {1,2,3,4,5,6,7,23,9}, b; //compound declaration
var j = a.length;
b = new int[j];
for (var i : a)
    b[--j] = i; //--j so you don't have to subtract 1 from j. Otherwise you would get ArrayIndexOutOfBoundsException;
System.out.println(Arrays.toString(b));

当然，如果你需要a是反向数组就用

a = b; //after the loop

使用流来反转

这里已经有很多答案，主要集中在就地修改数组。但是为了完整起见，这里有另一种使用Java流来保留原始数组并创建一个新的反向数组的方法:

int[] a = {8, 6, 7, 5, 3, 0, 9};
int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray();