什么是最简单的方法来颠倒ArrayList？
什么是最简单的方法来扭转这个ArrayList？
ArrayList 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()); 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);
不是最简单的方法，但如果你是recursion的粉丝，你可能会对以下方法反转ArrayList感兴趣：
public ArrayList<Object> reverse(ArrayList<Object> list) { if(list.size() > 1) { Object value = list.remove(0); reverse(list); list.add(value); } return list; }
或者非recursion地：
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; }
解决scheme不使用额外的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); }
这里的技巧是定义“反向”。 可以修改列表，按相反顺序创build副本，或以相反顺序创build视图。
Collections.reverse最直观的方法就是Collections.reverse ：
Collections.reverse(myList);
这个方法修改了这个列表 。 也就是说， Collections.reverse获取列表并覆盖其元素，而不会留下未反转的副本。 这适用于某些用例，但不适用于其他用例; 此外，它假定列表是可修改的。 如果这是可以接受的，我们很好。
如果没有，可以按照相反的顺序创build一个副本 ：
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的stream API， 有些人比上面更简洁明了：
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()对结果列表做了很less的保证。 如果要确保结果作为ArrayList返回，请改用Collectors.toCollection(ArrayList::new) 。
第三个选项是以相反的顺序创build一个视图 。 这是一个更复杂的解决scheme，值得进一步阅读/自己的问题。 番石榴的名单＃逆转法是一个可行的起点。
select一个“最简单”的实现是读者的一个练习。
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)); }
多一点可读性:)
public static <T> ArrayList<T> reverse(ArrayList<T> list) { int length = list.size(); ArrayList<T> result = new ArrayList<T>(length); for (int i = length - 1; i >= 0; i--) { result.add(list.get(i)); } return result; }
另一个recursion解决scheme
public static String reverse(ArrayList<Float> list) { if (list.size() == 1) { return " " +list.get(0); } else { return " "+ list.remove(list.size() - 1) + reverse(list); } }
以防万一我们正在使用Java 8 ，那么我们可以利用Stream。 ArrayList是随机访问列表，我们可以以相反的顺序获取元素stream，然后将其收集到一个新的ArrayList 。
public static void main(String[] args) { ArrayList<String> someDummyList = getDummyList(); System.out.println(someDummyList); int size = someDummyList.size() - 1; ArrayList<String> someDummyListRev = IntStream.rangeClosed(0,size).mapToObj(i->someDummyList.get(size-i)).collect(Collectors.toCollection(ArrayList::new)); System.out.println(someDummyListRev); } private static ArrayList<String> getDummyList() { ArrayList dummyList = new ArrayList(); //Add elements to ArrayList object dummyList.add("A"); dummyList.add("B"); dummyList.add("C"); dummyList.add("D"); return dummyList; }
上面的方法不适合LinkedList，因为这不是随机访问。 我们也可以利用instanceof来检查。
