Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

Java Top

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:


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

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()) {

3.3. Collections.reverse()

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


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

for (String item : list) {

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:


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()) {

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:


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) {

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.

Java bottom

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

Generic footer banner
Comments are closed on this article!