Iterating Backward Through a List

1. Overview

In this quick tutorial, we’ll learn about various ways in which we can iterate backward through a list in Java.

2. Iterator in Java

An Iterator is an interface in the Java Collections Framework that allows us to iterate over the elements in a collection. It was introduced in Java 1.2 as a replacement of Enumeration.

3. Iterating Backward Using Core Java

3.1. Reversed for Loop

The most simple implementation is to use a for loop to start from the last element of the list, and decrement the index as we reach the beginning of the list:

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

3.2. ListIterator

We can use a ListIterator to iterate over the elements in the list.

Providing the size of the list as an index to the ListIterator will give us an iterator pointing to the end of the list:

ListIterator listIterator = list.listIterator(list.size());

This iterator now allows us to traverse the list in the reverse direction:

while (listIterator.hasPrevious()) {
    System.out.println(listIterator.previous());
}

3.3. Collections.reverse()

The Collections class in Java provides a static method to reverse the order of elements in a specified list:

Collections.reverse(list);

The reversed list can then be used to iterate backward over the original elements:

for (String item : list) {
    System.out.println(item);
}

This method, however, reverses the actual list by changing the order of elements in-place, and may not be desirable in many cases.

4. Iterating Backwards Using Apache’s ReverseListIterator

The Apache Commons Collections library has a nice ReverseListIterator class that allows us to loop through the elements in a list without actually reversing it.

Before we start, we need to import the latest dependencies from Maven Central:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.1</version>
</dependency>

We can create a new ReverseListIterator by passing the original list as a constructor parameter:

ReverseListIterator reverseListIterator = new ReverseListIterator(list);

We can then use this iterator to traverse the list backward:

while (reverseListIterator.hasNext()) {
    System.out.println(reverseListIterator.next());
}

5. Iterating Backwards Using Guava’s Lists.reverse()

Similarly, the Google Guava library also provides a static reverse() method in its Lists class that returns a reverse view of the provided list.

Latest Guava version can be found over on Maven Central:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.0.1-jre</version>
</dependency>

Invoking the static method reverse() on the Lists class gives us the list in a reversed way:

List<String> reversedList = Lists.reverse(list);

The reversed list can then be used to iterate backward over the original list:

for (String item : reversedList) {
    System.out.println(item);
}

This method returns a new list with the elements of the original list in reversed order.

6. Conclusion

In this article, we’ve looked at different ways of iterating backward through a list in Java. We went through some examples using core Java, as well as using popular third-party libraries.

The source code for this article and the relevant test cases are available over on GitHub.