SequencedCollection：集合终于有了「两端」

接口家族与默认方法01

public interface SequencedCollection<E> extends Collection<E> {
    void addFirst(E e);          // 默认抛 UnsupportedOperationException
    void addLast(E e);           // 默认抛 UnsupportedOperationException
    E getFirst();                // 默认用 iterator().next()
    E getLast();                 // 默认遍历到最后一个
    E removeFirst();             // 默认用 iterator().remove()
    E removeLast();              // 默认遍历到最后一个再删
    SequencedCollection<E> reversed();
}

public interface SequencedSet<E> extends SequencedCollection<E>, Set<E> {
    SequencedSet<E> reversed();  // 协变返回
}

public interface SequencedMap<K,V> extends Map<K,V> {
    Map.Entry<K,V> firstEntry();
    Map.Entry<K,V> lastEntry();
    Map.Entry<K,V> pollFirstEntry();
    Map.Entry<K,V> pollLastEntry();
    V putFirst(K k, V v);
    V putLast(K k, V v);
    SequencedSet<K> sequencedKeySet();
    SequencedCollection<V> sequencedValues();
    SequencedSet<Map.Entry<K,V>> sequencedEntrySet();
    SequencedMap<K,V> reversed();
}

• addFirst/addLast 的默认实现直接抛 UOE，因此不支持改序的实现（TreeSet/TreeMap）无需重写就自动拒绝。
• getFirst/getLast/removeFirst/removeLast 有基于迭代器的默认实现；空集合时 get/remove 抛 NoSuchElementException。
• SequencedMap 没有继承 SequencedCollection，因为 Map 不是 Collection；它单独提供 sequenced 视图。
• LinkedHashSet、LinkedHashMap 还额外实现了 SequencedSet / SequencedMap，并覆盖了端点操作。

四个实现的真实行为02

ArrayList：端点操作可能触发扩容和搬移

addFirst 需要把已有元素整体右移一位，复杂度 O(n)；addLast 均摊 O(1)。频繁在头部插入时，ArrayDeque 更合适。

LinkedHashSet：addFirst 是「移动」，不是「重复添加」

LinkedHashSet<String> set = new LinkedHashSet<>(List.of("a", "b", "c"));
set.addFirst("c");
System.out.println(set); // [c, a, b] —— c 被移动到最前，没有重复

LinkedHashMap：putFirst 同时更新值和顺序

LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("a", 1);
map.put("b", 2);
map.putFirst("b", 20);
System.out.println(map); // {b=20, a=1}
System.out.println(map.get("b")); // 20

TreeSet / TreeMap：顺序由比较器决定

TreeSet<Integer> set = new TreeSet<>(List.of(2, 1));
try {
    set.addFirst(0);
} catch (UnsupportedOperationException e) {
    System.out.println("顺序由比较器决定，不能插到端点");
}

TreeSet 的 first/last 是「最小/最大」而非「最早/最晚插入」。对它调用 addFirst 会破坏排序不变式，所以接口选择抛异常而不是默默重排。

空集合与 null 的边界03

List.of() 等不可变集合实现了 SequencedCollection，但所有修改方法都抛 UOE。读取端点仍然可用（只要非空）。

四个常见配方01

1. 取最近 N 条记录

Deque<LogEvent> recent = new ArrayDeque<>();
recent.addFirst(event);
if (recent.size() > 100) {
    recent.removeLast();
}

2. 从后往前遍历，但不动数据

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

3. 让 LinkedHashMap 同时支持两端插入

LinkedHashMap<String, Integer> lru = new LinkedHashMap<>(16, 0.75f, true);
lru.put("a", 1);
lru.put("b", 2);
lru.get("a");          // 访问顺序：b, a
lru.putFirst("b", 2);  // 手动把 b 移到最前：b, a

4. 只读视图

SequencedCollection<String> readOnly =
        Collections.unmodifiableSequencedCollection(list);
readOnly.getFirst();   // 可以读
readOnly.addFirst("x"); // UnsupportedOperationException

可运行示例：两端与反向视图02

import java.util.*;

public class SequencedDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("b", "c"));
        list.addFirst("a");
        list.addLast("d");
        System.out.println("list=" + list);
        System.out.println("first=" + list.getFirst() + ", last=" + list.getLast());
        System.out.println("reversed=" + list.reversed());

        LinkedHashSet<String> set = new LinkedHashSet<>(List.of("a", "b", "c"));
        set.addFirst("c");
        System.out.println("set=" + set);

        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
        map.put("a", 1);
        map.put("b", 2);
        map.putFirst("b", 20);
        System.out.println("map=" + map);
        System.out.println("firstEntry=" + map.firstEntry());

        TreeMap<String, Integer> tree = new TreeMap<>(Map.of("b", 2, "a", 1));
        System.out.println("treeFirst=" + tree.firstEntry());
        try {
            tree.putFirst("z", 26);
        } catch (UnsupportedOperationException e) {
            System.out.println("tree.putFirst -> UOE");
        }
    }
}

list=[a, b, c, d]
first=a, last=d
reversed=[d, c, b, a]
set=[c, a, b]
map={b=20, a=1}
firstEntry=b=20
treeFirst=a=1
tree.putFirst -> UOE

先猜再看01

费曼自检：接口与实现02