How to get a reversed list view on a list in Java?

Use the .clone() method on your List. It will return a shallow copy, meaning that it will contain pointers to the same objects, so you won't have to copy the list. Then just use Collections.

Ergo,

Collections.reverse(list.clone());

If you are using a List and don't have access to clone() you can use subList():

List<?> shallowCopy = list.subList(0, list.size());
Collections.reverse(shallowCopy);

If i have understood correct then it is one line of code .It worked for me .

 Collections.reverse(yourList);

Its not exactly elegant, but if you use List.listIterator(int index) you can get a bi-directional ListIterator to the end of the list:

//Assume List<String> foo;
ListIterator li = foo.listIterator(foo.size());

while (li.hasPrevious()) {
   String curr = li.previous();
}

SequencedCollection#reversed

Since Java 21 there is a new interface SequencedCollection (which is a superinteface for List). It has the method reversed() which provides a reverse-ordered view of a collection:

jshell> List.of(1, 2, 3, 4, 5).reversed()
$1 ==> [5, 4, 3, 2, 1]

See JEP 431 and video.

I use this:

public class ReversedView<E> extends AbstractList<E>{

    public static <E> List<E> of(List<E> list) {
        return new ReversedView<>(list);
    }

    private final List<E> backingList;

    private ReversedView(List<E> backingList){
        this.backingList = backingList;
    }

    @Override
    public E get(int i) {
        return backingList.get(backingList.size()-i-1);
    }

    @Override
    public int size() {
        return backingList.size();
    }

}

like this:

ReversedView.of(backingList) // is a fully-fledged generic (but read-only) list

java.util.Deque has descendingIterator() - if your List is a Deque, you can use that.

Collections.reverse(nums) ... It actually reverse the order of the elements. Below code should be much appreciated -

List<Integer> nums = new ArrayList<Integer>();
nums.add(61);
nums.add(42);
nums.add(83);
nums.add(94);
nums.add(15);
//Tosort the collections uncomment the below line
//Collections.sort(nums); 

Collections.reverse(nums);

System.out.println(nums);

Output: 15,94,83,42,61

Since Java 21 use List.reversed.

Returns a reverse-ordered view of this collection. The encounter order of elements in the returned view is the inverse of the encounter order of elements in this collection. The reverse ordering affects all order-sensitive operations, including those on the view collections of the returned view. If the collection implementation permits modifications to this view, the modifications "write through" to the underlying collection. Changes to the underlying collection might or might not be visible in this reversed view, depending upon the implementation.

So you have a reversed view of the original list.

I know this is an old post but today I was looking for something like this. In the end I wrote the code myself:

private List reverseList(List myList) {
    List invertedList = new ArrayList();
    for (int i = myList.size() - 1; i >= 0; i--) {
        invertedList.add(myList.get(i));
    }
    return invertedList;
}

Not recommended for long Lists, this is not optimized at all. It's kind of an easy solution for controlled scenarios (the Lists I handle have no more than 100 elements).

Hope it helps somebody.

You can also invert the position when you request an object:

Object obj = list.get(list.size() - 1 - position);

For small sized list we can create LinkedList and then can make use of descending iterator as:

List<String> stringList = new ArrayList<>(Arrays.asList("One", "Two", "Three"));
stringList.stream().collect(Collectors.toCollection(LinkedList::new))
         .descendingIterator().
         forEachRemaining(System.out::println); // Three, Two, One
System.out.println(stringList); // One, Two, Three

UPDATE 2024.06.16:

After an awesome comment from Emmanuel Bourg, I took another look at the code and upgraded it to be modern-style null safe, and incorporating his excellent suggestion. The original code is captured below the last horizontal rule.

It's considerably more aligned with the latest versions of Java, i.e., exploiting null is a type-hole, mutating a method parameter is a type-hole code smell, and mutability being restricted to as small a block of code within a single method as possible to improve FP composability (as opposed to the weaker and error-prone OOP reusability).

For anyone on Java 21 or later, use List.reversed().

For anyone on Java 8 through Java 20 who...

1. Wants to guard against null
2. Does not want to modify the passed parameter, List<T> (a strong code smell)
3. Wants to return an unmodifiable List<T>
4. Does not want to use a third-party library like Guava
5. Wants a function that follows the Java Collection API Stream<T>'s fluent calling style
6. Wants to see modern style code (and to move away from the very C-like code from the late 1990s)
7. Wants to move towards expressions (and to move away from statements)
8. Wants to avoid reimplementing as much as possible (in this case, by calling the mutation-oriented imperative method, Collections.reverse(), already present in the Java Collections API)

...here's a useful solution I've generated:

/**
 * Returns a {@link Collections#unmodifiableList} with the contained instances in reverse order.
 *
 * @param list the list to copy from while reversing ({@code null} safe)
 * @param <T> the type of instances contained in the {@link list}
 * @return a {@link Collections#unmodifiableList} with the contained instances in reverse order
 */
public static <T> List<T> reverse(List<T> list) {
  return Optional.ofNullable(list)
      .filter(listNonNull ->
         !listNonNull.isEmpty())
      .map(listNonEmpty -> {
        if (listNonEmpty.size() == 1) {
          return Collections.unmodifiableList(listNonEmpty);
        }

        var listNonEmptyCopy = new ArrayList<>(listNonEmpty);
        Collections.reverse(listNonEmptyCopy);

        return Collections.unmodifiableList(listNonEmptyCopy);
      })
      .orElse(List.of());
}

Originally Posted Code that was updated above (DO NOT USE):

/**
 * Reverse the order of the instances returning an unmodifiable list.
 *
 * @param list the list to copy from while reversing
 * @param <T> the type of instances contained in the list
 * @return an unmodifiable list with the contained instances in reverse order
 */
public static <T> List<T> reverse(List<T> list) {
  if (list.size() > 1) {
    var size = list.size();

    return IntStream.range(0, size)
        .mapToObj(index -> list.get(size - 1 - index))
        .toList();
  } else if (list.size() == 1) {
    return list;
  }

  return List.of();
}

You can also do this:

static ArrayList<String> reverseReturn(ArrayList<String> alist)
{
   if(alist==null || alist.isEmpty())
   { 
       return null;
   }

   ArrayList<String> rlist = new ArrayList<>(alist);

   Collections.reverse(rlist);
   return rlist;
}