以下是我想到的:

// solution 1 - boiler plated 
Integer[] original = {100, 200, 300, 400};
Integer[] reverse = new Integer[original.length];

int lastIdx = original.length -1;
int startIdx = 0;

for (int endIdx = lastIdx; endIdx >= 0; endIdx--, startIdx++)
   reverse[startIdx] = original[endIdx];

System.out.printf("reverse form: %s", Arrays.toString(reverse));

// solution 2 - abstracted 
// convert to list then use Collections static reverse()
List<Integer> l = Arrays.asList(original);
Collections.reverse(l);
System.out.printf("reverse form: %s", l);

试试下面的代码:

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

小菜一碟。 我是为字符串做的，但没有太大不同

如果使用更原始的数据(即char, byte, int等)，那么你可以做一些有趣的异或操作。

public static void reverseArray4(int[] array) {
    int len = array.length;
    for (int i = 0; i < len/2; i++) {
        array[i] = array[i] ^ array[len - i  - 1];
        array[len - i  - 1] = array[i] ^ array[len - i  - 1];
        array[i] = array[i] ^ array[len - i  - 1];
    }
}

for(int i=validData.length-1; i>=0; i--){
  System.out.println(validData[i]);
 }

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

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