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

所以创建你的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();
  }
}

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

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

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

所以创建你的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();
  }
}

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

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

在Java 8的情况下，我们还可以使用IntStream来反转整数数组:

int[] sample = new int[]{1,2,3,4,5};
int size = sample.length;
int[] reverseSample = IntStream.range(0,size).map(i -> sample[size-i-1])
                      .toArray(); //Output: [5, 4, 3, 2, 1]

具有o(n)个时间复杂度和o(1)个空间复杂度的解。

void reverse(int[] array) {
    int start = 0;
    int end = array.length - 1;
    while (start < end) {
        int temp = array[start];
        array[start] = array[end];
        array[end] = temp;
        start++;
        end--;
    }
}

以下是我想到的:

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

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