// 基于 JDK 25 (本地 D:/1ForCode/JAVA_Source), java.util.LinkedHashMap —— 三个回调钩子与 get
void afterNodeRemoval(Node<K,V> e) { // unlink    HashMap.removeNode 删完桶后回调：把节点从链表上摘下
    LinkedHashMap.Entry<K,V> p =
        (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
    p.before = p.after = null;      // 断引用，防止已删节点把整条链钉在内存里
    if (b == null)
        head = a;
    else
        b.after = a;
    if (a == null)
        tail = b;
    else
        a.before = b;
}

void afterNodeInsertion(boolean evict) { // possibly remove eldest
    LinkedHashMap.Entry<K,V> first;
    if (evict && (first = head) != null && removeEldestEntry(first)) {
        K key = first.key;
        removeNode(hash(key), key, null, false, true);   // 淘汰链表头=最老节点。evict 在构造/反序列化灌数据时是 false，半成品阶段不触发淘汰
    }
}

// Called after update, but not after insertion
void afterNodeAccess(Node<K,V> e) {
    LinkedHashMap.Entry<K,V> last;
    LinkedHashMap.Entry<K,V> first;
    if ((putMode == PUT_LAST || (putMode == PUT_NORM && accessOrder)) && (last = tail) != e) {   // JDK 17 的条件只有 accessOrder；已在尾部就什么都不做
        // move node to last
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        p.after = null;             // 先摘：下面四个分支处理 p 是头/是中间两种位置
        if (b == null)
            head = a;
        else
            b.after = a;
        if (a != null)
            a.before = b;
        else
            last = b;
        if (last == null)           // 再挂到尾部
            head = p;
        else {
            p.before = last;
            last.after = p;
        }
        tail = p;
        ++modCount;                 // 挪链表不改 size 但改遍历顺序，也算结构修改——accessOrder=true 时迭代中 get 会 fail-fast，经典坑
    } else if (putMode == PUT_FIRST && (first = head) != e) {
        // move node to first
        // ... 与上一分支镜像对称：把 p 摘下挂到 head，putFirst 覆盖已有 key 时走这里，略
    }
}

public V get(Object key) {
    Node<K,V> e;
    if ((e = getNode(key)) == null)   // 查找完全复用 HashMap.getNode，重写 get 只为了下面两行
        return null;
    if (accessOrder)
        afterNodeAccess(e);           // 读也"提鲜"：LRU 里的 R 就是这一行
    return e.value;
}

// ... getOrDefault 同样补了 afterNodeAccess；containsKey 没重写——探测不算"使用"，不影响 LRU 顺序

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
    return false;   // 默认永不淘汰。做 LRU 只需重写这一个方法，链表代码一行不用碰
}

// 基于 JDK 25 (本地 D:/1ForCode/JAVA_Source), java.util.LinkedHashMap —— 顺序遍历与迭代器
public boolean containsValue(Object value) {
    for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {   // 顺链表走 O(size)；HashMap 得扫整个桶数组 O(capacity)
        V v = e.value;
        if (v == value || (value != null && value.equals(v)))
            return true;
    }
    return false;
}

abstract class LinkedHashIterator {
    LinkedHashMap.Entry<K,V> next;
    LinkedHashMap.Entry<K,V> current;
    int expectedModCount;
    boolean reversed;               // JDK 21 的 reversed() 视图复用同一个迭代器，只是反着走

    LinkedHashIterator(boolean reversed) {
        this.reversed = reversed;
        next = reversed ? tail : head;
        expectedModCount = modCount;
        current = null;
    }

    public final boolean hasNext() {
        return next != null;
    }

    final LinkedHashMap.Entry<K,V> nextNode() {
        LinkedHashMap.Entry<K,V> e = next;
        if (modCount != expectedModCount)   // accessOrder=true 时迭代中 get 也会改 modCount，在这里炸 CME
            throw new ConcurrentModificationException();
        if (e == null)
            throw new NoSuchElementException();
        current = e;
        next = reversed ? e.before : e.after;   // 顺链表走，顺序与桶分布完全无关
        return e;
    }

    public final void remove() {
        Node<K,V> p = current;
        if (p == null)
            throw new IllegalStateException();
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        current = null;
        removeNode(p.hash, p.key, null, false, false);   // 走 HashMap.removeNode，回调 afterNodeRemoval 同步断链
        expectedModCount = modCount;
    }
}