反转ArrayList的最简单方法是什么？

Question

反转此ArrayList的最简单方法是什么？

ArrayList<Integer> aList = new ArrayList<>();

//Add elements to ArrayList object
aList.add("1");
aList.add("2");
aList.add("3");
aList.add("4");
aList.add("5");

while (aList.listIterator().hasPrevious())
  Log.d("reverse", "" + aList.listIterator().previous());

Answer 1

Collections.reverse(aList);

示例(参考):

ArrayList aList = new ArrayList();
//Add elements to ArrayList object
aList.add("1");
aList.add("2");
aList.add("3");
aList.add("4");
aList.add("5");
Collections.reverse(aList);
System.out.println("After Reverse Order, ArrayList Contains : " + aList);

Answer 2

不是最简单的方法,但如果你是递归的粉丝,你可能会对以下方法感兴趣来反转ArrayList:

public ArrayList<Object> reverse(ArrayList<Object> list) {
    if(list.size() > 1) {                   
        Object value = list.remove(0);
        reverse(list);
        list.add(value);
    }
    return list;
}

或非递归:

public ArrayList<Object> reverse(ArrayList<Object> list) {
    for(int i = 0, j = list.size() - 1; i < j; i++) {
        list.add(i, list.remove(j));
    }
    return list;
}

Answer 3

这里的诀窍是定义"反向".可以在适当的位置修改列表,以相反的顺序创建副本,或者以相反的顺序创建视图.

直观地说,最简单的方法是Collections.reverse:

Collections.reverse(myList);

此方法可以修改列表.也就是说,Collections.reverse获取列表并覆盖其元素,不留下任何未反转的副本.这适用于某些用例,但不适用于其他用例; 此外,它假定列表是可修改的.如果这是可以接受的,我们很好.

如果没有,可以按相反顺序创建副本:

static <T> List<T> reverse(final List<T> list) {
    final List<T> result = new ArrayList<>(list);
    Collections.reverse(result);
    return result;
}

这种方法有效,但需要对列表进行两次迭代.复制构造函数(new ArrayList<>(list))遍历列表,同样如此Collections.reverse.如果我们如此倾向,我们可以重写此方法只迭代一次:

static <T> List<T> reverse(final List<T> list) {
    final int size = list.size();
    final int last = size - 1;

    // create a new list, with exactly enough initial capacity to hold the (reversed) list
    final List<T> result = new ArrayList<>(size);

    // iterate through the list in reverse order and append to the result
    for (int i = last; i >= 0; --i) {
        final T element = list.get(i);
        result.add(element);
    }

    // result now holds a reversed copy of the original list
    return result;
}

这样更有效,但也更冗长.

或者,我们可以重写上面的内容以使用Java 8的streamAPI,有些人发现它比上面的更简洁易读:

static <T> List<T> reverse(final List<T> list) {
    final int last = list.size() - 1;
    return IntStream.rangeClosed(0, last) // a stream of all valid indexes into the list
        .map(i -> (last - i))             // reverse order
        .mapToObj(list::get)              // map each index to a list element
        .collect(Collectors.toList());    // wrap them up in a list
}

NB.这Collectors.toList()对结果列表几乎没有任何保证.如果要确保结果以ArrayList形式返回,请Collectors.toCollection(ArrayList::new)改用.

第三种选择是以相反的顺序创建视图.这是一个更复杂的解决方案,值得进一步阅读/自己的问题.番石榴的名单#反向法是一个可行的起点.

选择"最简单"的实现仍然是读者的练习.

Answer 4

解决方案,无需使用额外的ArrayList或add()和remove()方法的组合.如果你必须撤销一个巨大的列表,两者都会产生负面影响.

 public ArrayList<Object> reverse(ArrayList<Object> list) {

   for (int i = 0; i < list.size() / 2; i++) {
     Object temp = list.get(i);
     list.set(i, list.get(list.size() - i - 1));
     list.set(list.size() - i - 1, temp);
   }

   return list;
 }

Answer 5

ArrayList<Integer> myArray = new ArrayList<Integer>();

myArray.add(1);
myArray.add(2);
myArray.add(3);

int reverseArrayCounter = myArray.size() - 1;

for (int i = reverseArrayCounter; i >= 0; i--) {
    System.out.println(myArray.get(i));
}

Answer 6

从 Java 21 开始，您可以使用ArrayList#reversed(). 何处ArrayList施行SequencedCollection。

这是添加到集合框架中的序列集合的一部分。