Devops Monk

// List — index-based
var list = List.of("a", "b", "c");
String first = list.get(0);               // first element
String last  = list.get(list.size() - 1); // last element — verbose, error-prone

// Deque — special methods
Deque<String> deque = new ArrayDeque<>(List.of("a", "b", "c"));
String first = deque.getFirst();  // works
String last  = deque.getLast();   // works, but Deque only

// LinkedHashSet — NO uniform access at all
LinkedHashSet<String> set = new LinkedHashSet<>(List.of("a", "b", "c"));
String first = set.iterator().next();  // iterate, no direct access
// Last element? No way without iterating the whole set

// SortedSet
SortedSet<String> sorted = new TreeSet<>(List.of("a", "b", "c"));
String first = sorted.first();  // different method name than Deque
String last  = sorted.last();   // different method name than Deque

public interface SequencedCollection<E> extends Collection<E> {
    SequencedCollection<E> reversed();
    default void addFirst(E e) { throw new UnsupportedOperationException(); }
    default void addLast(E e)  { throw new UnsupportedOperationException(); }
    default E getFirst() {
        return this.iterator().next();
    }
    default E getLast() {
        return this.reversed().iterator().next();
    }
    default E removeFirst() { ... }
    default E removeLast()  { ... }
}

public interface SequencedSet<E> extends SequencedCollection<E>, Set<E> {
    SequencedSet<E> reversed();  // covariant return — returns SequencedSet
}

public interface SequencedMap<K,V> extends Map<K,V> {
    SequencedMap<K,V> reversed();
    Map.Entry<K,V> firstEntry();
    Map.Entry<K,V> lastEntry();
    K firstKey();
    K lastKey();
    Map.Entry<K,V> pollFirstEntry();
    Map.Entry<K,V> pollLastEntry();
    default void putFirst(K k, V v) { ... }
    default void putLast(K k, V v)  { ... }
}

List<String> list = new ArrayList<>(List.of("a", "b", "c", "d"));

// New uniform API
String first = list.getFirst();   // "a"
String last  = list.getLast();    // "d"

list.addFirst("Z");  // ["Z", "a", "b", "c", "d"]
list.addLast("X");   // ["Z", "a", "b", "c", "d", "X"]

list.removeFirst();  // removes "Z"
list.removeLast();   // removes "X"

// Reversed view — not a copy, live view
for (String s : list.reversed()) {
    System.out.print(s + " ");  // d c b a
}

// Works with List.of() — unmodifiable
List<String> immutable = List.of("a", "b", "c");
immutable.getFirst();  // "a" — OK
immutable.addFirst("Z");  // UnsupportedOperationException

Deque<String> deque = new ArrayDeque<>(List.of("a", "b", "c"));

deque.getFirst();  // "a" — existing method, unchanged
deque.getLast();   // "c" — existing method, unchanged
deque.reversed();  // NEW — reversed view

LinkedHashSet<String> set = new LinkedHashSet<>();
set.add("first");
set.add("second");
set.add("third");

set.getFirst();  // "first" — NEW
set.getLast();   // "third" — NEW

// Reversed iteration
set.reversed().forEach(System.out::println);  // third, second, first

LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("x", 1);
map.put("y", 2);
map.put("z", 3);

map.firstEntry();   // x=1
map.lastEntry();    // z=3
map.firstKey();     // "x"
map.lastKey();      // "z"

map.pollFirstEntry(); // removes and returns x=1
map.pollLastEntry();  // removes and returns z=3

// Reversed view
map.reversed().firstEntry();  // z=3 (was last)
map.putFirst("a", 0);  // inserts at beginning
map.putLast("z", 3);   // inserts at end

TreeSet<Integer> sorted = new TreeSet<>(Set.of(3, 1, 4, 1, 5, 9, 2, 6));

sorted.getFirst();  // 1 — equivalent to sorted.first()
sorted.getLast();   // 9 — equivalent to sorted.last()

// Reversed — ascending becomes descending
sorted.reversed().getFirst();  // 9

List<String> original = new ArrayList<>(List.of("a", "b", "c"));
List<String> reversed = original.reversed();

original.add("d");
System.out.println(reversed);  // [d, c, b, a] — reflects the addition

reversed.removeFirst();  // removes "d" from original
System.out.println(original);  // [a, b, c]

// Unmodifiable wrappers
SequencedCollection<String> unmodifiable =
    Collections.unmodifiableSequencedCollection(list);

SequencedSet<String> unmodifiableSet =
    Collections.unmodifiableSequencedSet(set);

SequencedMap<String, Integer> unmodifiableMap =
    Collections.unmodifiableSequencedMap(map);

// If you have:
class MyDequeList<E> implements List<E>, Deque<E> {
    // Must override reversed() explicitly to resolve ambiguity
    @Override
    public MyDequeList<E> reversed() { ... }
}

// BEFORE Java 21 — processing a task queue
LinkedHashMap<String, Task> queue = new LinkedHashMap<>();
// ... populate ...

// Get the oldest task (first inserted)
Map.Entry<String, Task> oldest = queue.entrySet().iterator().next();

// Get the newest task (last inserted)
Map.Entry<String, Task> newest = null;
for (Map.Entry<String, Task> e : queue.entrySet()) {
    newest = e;  // iterate entire map to find last
}

// AFTER Java 21
Map.Entry<String, Task> oldest = queue.firstEntry();
Map.Entry<String, Task> newest = queue.lastEntry();