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

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

反转一个int数组，你交换元素直到你到达中点，像这样:

for(int i = 0; i < validData.length / 2; i++)
{
    int temp = validData[i];
    validData[i] = validData[validData.length - i - 1];
    validData[validData.length - i - 1] = temp;
}

你这样做的方式是，你交换每个元素两次，所以结果与初始列表相同。

Collections.reverse(Arrays.asList(yourArray));

java.util.Collections.reverse()可以反转java.util.Lists和java.util.Arrays.asList()返回一个列表，该列表包装了您传递给它的特定数组，因此在调用Collections.reverse()之后，yourArray将被反转。

其代价只是创建一个list对象，不需要额外的库。

在Tarik和他们的评论者的回答中已经提出了一个类似的解决方案，但我认为这个答案会更简洁，更容易被分析。

只是为了它。人们通常只需要反向排列的数组或列表上的“视图”，而不是在处理流和集合时完全不需要反向数组，而是原始数组/集合上的“反向”视图。，最好创建一个在列表/数组上具有反向视图的工具包。

所以创建你的Iterator实现，它接受一个数组或列表并提供输入。

/// Reverse Iterator
public class ReverseIterator<T> implements Iterator<T> {
  private int index;
  private final List<T> list;
  public ReverseIterator(List<T> list) {
     this.list = list;
     this.index = list.size() - 1;
  }
  public boolean hasNext() {
    return index >= 0 ? true : false;
  }
  public T next() {
    if(index >= 0) 
      return list.get(index--);
    else 
      throw new NoSuchElementException();
  }
}

数组情况的实现非常类似。当然，迭代器也可以是流或集合的源。

因此，当你想做的只是迭代数组/列表或将其提供给流或新的集合/数组时，创建一个新数组并不总是最好的。

下面是要在您的机器上运行的完整程序。

public class ReverseArray {
    public static void main(String[] args) {
        int arr[] = new int[] { 10,20,30,50,70 };
        System.out.println("reversing an array:");
        for(int i = 0; i < arr.length / 2; i++){
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }   
    }
}

对于矩阵上使用数组的程序，这将是很好的来源。通过链接。

我认为如果你声明显式变量来跟踪你在每次循环迭代中交换的下标，那么遵循算法的逻辑会更容易一些。

public static void reverse(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;
    }
}

我还认为在while循环中执行这个操作更具可读性。

public static void reverse(int[] data) {
    int left = 0;
    int right = data.length - 1;

    while( left < right ) {
        // swap the values at the left and right indices
        int temp = data[left];
        data[left] = data[right];
        data[right] = temp;

        // move the left and right index pointers in toward the center
        left++;
        right--;
    }
}