反转此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());


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


评论

@AgarwalShankar我遇到一个错误，需要ArrayList无效。我错过了什么吗？

– Sagar Devanga
2015年1月5日下午6:52
@SagarDevanga该列表在原位反转，未返回。

–致癌物质
15年5月30日在20:24
Collections.reverse（List）;我在一个Android项目中使用它，效果很好。

–达米尔·瓦雷瓦茨（Damir Varevac）
18年7月7日在15:23

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


评论

我可能是错的，但是在您的非递归示例中，int j是否不会随每次迭代更新？您将其初始化为j = list.size（）-1，但我不认为for循环的初始化部分会随着每次迭代而更新吗？

–陈百强
2014年11月7日在2:26


@Turbo j不需要每次迭代都更新。它被初始化为ArrayList的最后一个索引，并用于访问最后一个元素。在for循环中，最后一个元素被删除并插入到索引i中； i递增直到到达ArrayList中的最后一个位置。

–托德
2014年11月7日在2:44
是的，但是在第二次迭代中，由于您尝试访问j（原始ArrayList的最后一个索引），但是您已经删除了该索引处的对象，因此不会得到IndexOutOfBoundsException吗？

–陈百强
2014年11月7日，下午2:51
抱歉，只需运行代码，绝对可以。我忘了add（）将其他元素推入数组，因此数组本质上保持不变的大小。有趣的解决方案，谢谢！

–陈百强
2014年11月7日在3:01


@LukeUsherwood我同意这没有效率，但这不是问题。问题是最简单的方法，而递归方法要尽可能简单地自己实现。

–托德
18年6月29日下午2:00

#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的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()对结果列表的保证很少。如果要确保结果以ArrayList的形式返回，请改用Collectors.toCollection(ArrayList::new)。


第三个选项是按相反的顺序创建视图。这是一个更复杂的解决方案，值得进一步阅读/提出自己的问题。 Guava的Lists＃reverse方法是一个可行的起点。

选择“最简单”的实现作为练习是留给读者的。

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


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


#6 楼

以递归的方式反转ArrayList而不创建用于添加元素的新列表：

   public class ListUtil {

    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        System.out.println("Reverse Order: " + reverse(arrayList));

    }

    public static <T> List<T> reverse(List<T> arrayList) {
        return reverse(arrayList,0,arrayList.size()-1);
    }
    public static <T> List<T> reverse(List<T> arrayList,int startIndex,int lastIndex) {

        if(startIndex<lastIndex) {
            T t=arrayList.get(lastIndex);
            arrayList.set(lastIndex,arrayList.get(startIndex));
            arrayList.set(startIndex,t);
            startIndex++;
            lastIndex--;
            reverse(arrayList,startIndex,lastIndex);
        }
        return arrayList;
    }

}


#7 楼

我们也可以使用Java 8进行同样的操作。

public static<T> List<T> reverseList(List<T> list) {
        List<T> reverse = new ArrayList<>(list.size());

        list.stream()
                .collect(Collectors.toCollection(LinkedList::new))
                .descendingIterator()
                .forEachRemaining(reverse::add);

        return reverse;
    }


#8 楼

万一我们使用的是Java 8，则可以使用Stream。 ArrayList是随机访问列表，我们可以按相反的顺序获取元素流，然后将其收集到新的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进行检查。

#9 楼

更具可读性:) 

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


#10 楼

另一个递归解决方案

 public static String reverse(ArrayList<Float> list) {
   if (list.size() == 1) {
       return " " +list.get(0);
   }
   else {
       return " "+ list.remove(list.size() - 1) + reverse(list);
   } 
 }


#11 楼

简单的方法是您在Java中拥有“集合”。您只需要调用它并使用它的“ reverse（）”方法即可。
示例用法：
ArrayList<Integer> yourArrayList = new ArrayList<>();
    yourArrayList.add(1);
    yourArrayList.add(2);
    yourArrayList.add(3);
    //yourArrayList is: 1,2,3

Collections.reverse(yourArrayList); 
    // Now, yourArrayList is: 3,2,1

更多问题：@canerkaseler