Advertisement
Advertisement

## What is the Simplest Way to Reverse an ArrayList?

### Question

What is the simplest way to reverse this 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());
``````
2019/07/08
1
338
7/8/2019 10:01:38 PM

### Accepted Answer

``````Collections.reverse(aList);
``````

Example (Reference):

``````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);
``````
2017/05/19
806
5/19/2017 1:53:17 PM

Not the simplest way but if you're a fan of recursion you might be interested in the following method to reverse an ArrayList:

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

Or non-recursively:

``````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;
}
``````
2014/08/19

The trick here is defining "reverse". One can modify the list in place, create a copy in reverse order, or create a view in reversed order.

The simplest way, intuitively speaking, is `Collections.reverse`:

``````Collections.reverse(myList);
``````

This method modifies the list in place. That is, `Collections.reverse` takes the list and overwrites its elements, leaving no unreversed copy behind. This is suitable for some use cases, but not for others; furthermore, it assumes the list is modifiable. If this is acceptable, we're good.

If not, one could create a copy in reverse order:

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

This approach works, but requires iterating over the list twice. The copy constructor (`new ArrayList<>(list)`) iterates over the list, and so does `Collections.reverse`. We can rewrite this method to iterate only once, if we're so inclined:

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

This is more efficient, but also more verbose.

Alternatively, we can rewrite the above to use Java 8's `stream` API, which some people find more concise and legible than the above:

``````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. that `Collectors.toList()` makes very few guarantees about the result list. If you want to ensure the result comes back as an ArrayList, use `Collectors.toCollection(ArrayList::new)` instead.

The third option is to create a view in reversed order. This is a more complicated solution, and worthy of further reading/its own question. Guava's Lists#reverse method is a viable starting point.

Choosing a "simplest" implementation is left as an exercise for the reader.

2017/09/19

Solution without using extra ArrayList or combination of add() and remove() methods. Both can have negative impact if you have to reverse a huge list.

`````` 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;
}
``````
2018/07/17

``````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));
}
``````
2017/10/05

Reversing a ArrayList in a recursive way and without creating a new list for adding elements :

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

}
``````
2018/03/10

Licensed under: CC-BY-SA with attribution
Not affiliated with: Stack Overflow
Email: [email protected]