How can I process elements in reverse order across different collection types?

The "Sequenced Collections" feature in Java 21+, introduced in JEP 431, provides a uniform way to handle collections with a defined encounter order. How can I leverage this feature to process elements in reverse order, regardless of the specific collection implementation (e.g., List, Set, Map)?

The Sequenced Collections feature introduced with Java 21 added new interfaces to the Collections Framework:

• SequencedCollection

• SequencedSet

• SequencedMap

These interfaces unify the handling of collections that have a defined encounter order, allowing for consistent operations like accessing the first and last elements or processing elements in reverse order. This feature enhances the consistency and expressiveness of the Java Collections Framework, making it easier to perform common operations across different collection types. Existing collection implementations like LinkedList, LinkedHashSet, and LinkedHashMap have been retrofitted to implement these new interfaces.

Here is an example of how we can process elements in reverse order across different collection types:

import java.util.*;

class Main {
    public static void main(String[] args) {
        // An example for SequencedCollection (e.g. LinkedList)
        SequencedCollection<String> sequencedList = new LinkedList<>();
        sequencedList.add("Mango");
        sequencedList.add("Orange");
        sequencedList.add("Apple");

        System.out.println("Reversed SequencedCollection:");
        for (String item : sequencedList.reversed()) {
            System.out.println(item);
        }

        // Another example for SequencedCollection
        SequencedCollection<String> sequencedList2 = List.of("Mango", "Orange", "Apple");
        System.out.println("Another reversed SequencedCollection:");
        for (String item : sequencedList2.reversed()) {
            System.out.println(item);
        }

        // An example for SequencedSet (e.g. LinkedHashSet)
        SequencedSet<String> sequencedSet = new LinkedHashSet<>();
        sequencedSet.add("Mango");
        sequencedSet.add("Orange");
        sequencedSet.add("Apple");

        System.out.println("Reversed SequencedSet:");
        for (String item : sequencedSet.reversed()) {
            System.out.println(item);
        }

        // An example for SequencedMap (e.g. LinkedHashMap)
        SequencedMap<Integer, String> sequencedMap = new LinkedHashMap<>();
        sequencedMap.put(1, "Mango");
        sequencedMap.put(2, "Orange");
        sequencedMap.put(3, "Apple");

        System.out.println("Reversed SequencedMap:");
        for (Map.Entry<Integer, String> entry : sequencedMap.reversed().entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // Another example for SequencedMap
        SequencedMap<Integer, String> sequencedMap2 = new TreeMap<>();
        sequencedMap2.put(1, "Mango");
        sequencedMap2.put(2, "Orange");
        sequencedMap2.put(3, "Apple");
        System.out.println("Sorted by keys in natural (ascending) order:");
        for (Map.Entry<Integer, String> entry : sequencedMap2.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        System.out.println("Sorted by keys in descending order:");
        for (Map.Entry<Integer, String> entry : sequencedMap2.reversed().entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

Output:

Reversed SequencedCollection:
Apple
Orange
Mango
Another reversed SequencedCollection:
Apple
Orange
Mango
Reversed SequencedSet:
Apple
Orange
Mango
Reversed SequencedMap:
3: Apple
2: Orange
1: Mango
Sorted by keys in natural (ascending) order:
1: Mango
2: Orange
3: Apple
Sorted by keys in descending order:
3: Apple
2: Orange
1: Mango