public void display(){
  String x[]=new String [5];
  for(int i = 4 ; i > = 0 ; i-- ){//runs backwards

    //i is the nums running backwards therefore its printing from       
    //highest element to the lowest(ie the back of the array to the front) as i decrements

    System.out.println(x[i]);
  }
}

public class ArrayHandle {
    public static Object[] reverse(Object[] arr) {
        List<Object> list = Arrays.asList(arr);
        Collections.reverse(list);
        return list.toArray();
    }
}

试试下面的代码:

    int arr[] = new int[]{1,2,3,4,5,6,7};
    for(int i=0;i<arr.length/2;i++){
        int temp = arr[i];
        arr[i] = arr[(arr.length-1)-i];
        arr[(arr.length-1)-i] = temp;
     }
     System.out.println(Arrays.toString(arr));

   import java.util.Scanner;
class ReverseArray 
{
    public static void main(String[] args) 
    {
        int[] arra = new int[10];
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter Array Elements : ");
        for(int i = 0 ; i <arra.length;i++)
        {
            arra[i] = sc.nextInt();
        }

        System.out.println("Printing  Array : ");
        for(int i = 0; i <arra.length;i++)
        {
            System.out.print(arra[i] + " ");
        }

        System.out.println();
        System.out.println("Printing  Reverse Array : ");
        for(int i = arra.length-1; i >=0;i--)
        {
            System.out.print(arra[i] + " ");
        }
    }
}

public void getDSCSort(int[] data){
        for (int left = 0, right = data.length - 1; left < right; left++, right--){
            // swap the values at the left and right indices
            int temp = data[left];
            data[left]  = data[right];
            data[right] = temp;
        }
    }

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

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);
}