如何让存储UUID键的LinkedHashMap具备Navigable导航能力？

你的需求抓得很准——既要严格维护插入顺序（这正是LinkedHashMap的核心优势），又要实现条目间的导航（上一个、下一个、判断是否为最后一个），但LinkedHashMap本身没提供直接的导航API，而NavigableMap（比如TreeMap）又依赖键的排序而非插入顺序，所以得把两者的优势结合起来。下面分两种场景给出最优方案：

一、可以引入第三方库：用Apache Commons Collections的LinkedMap #

这是最省心的方案，Apache Commons Collections里的LinkedMap直接继承自LinkedHashMap，完全保留了插入顺序特性，还额外提供了你需要的所有导航方法：

• previousKey(K key)：按插入顺序获取当前键的上一个键
• nextKey(K key)：按插入顺序获取当前键的下一个键
• lastKey()：直接拿到最后一个插入的键
• isLastKey(K key)：判断当前键是否对应最后一个条目

用法示例：

import org.apache.commons.collections4.map.LinkedMap;

// 初始化你的Map
LinkedMap<UUID, CustomClass> map = new LinkedMap<>();
map.put(UUID.randomUUID(), new CustomClass());
map.put(UUID.randomUUID(), new CustomClass());

// 判断当前键是否为最后一个
UUID currentKey = ...;
boolean isLast = map.isLastKey(currentKey);

// 获取下一个实体
UUID nextKey = map.nextKey(currentKey);
CustomClass nextEntity = map.get(nextKey);

// 获取上一个实体
UUID prevKey = map.previousKey(currentKey);
CustomClass prevEntity = map.get(prevKey);

这个方案不用自己造轮子，完全依赖成熟稳定的API，代码简洁又可靠。

二、不能引入第三方库：自定义封装LinkedHashMap + 键顺序列表 #

如果项目限制不能加外部依赖，我们可以自己封装一个类，组合LinkedHashMap和一个维护插入顺序的键列表，来实现导航功能。核心逻辑就是同步维护Map和键列表的一致性：

自定义实现示例 #

import java.util.*;

public class OrderedNavigableMap<K, V> {
    private final LinkedHashMap<K, V> map = new LinkedHashMap<>();
    private final List<K> keyOrder = new ArrayList<>();

    // 添加/更新条目：新键追加到列表末尾，已有键不改变顺序
    public V put(K key, V value) {
        if (!map.containsKey(key)) {
            keyOrder.add(key);
        }
        return map.put(key, value);
    }

    // 删除条目：同时从列表中移除对应键
    public V remove(Object key) {
        keyOrder.remove(key);
        return map.remove(key);
    }

    // 获取当前键的上一个实体
    public V getPrevious(K currentKey) {
        int index = keyOrder.indexOf(currentKey);
        if (index <= 0) {
            return null; // 没有上一个条目
        }
        return map.get(keyOrder.get(index - 1));
    }

    // 获取当前键的下一个实体
    public V getNext(K currentKey) {
        int index = keyOrder.indexOf(currentKey);
        if (index == -1 || index >= keyOrder.size() - 1) {
            return null; // 键不存在或没有下一个条目
        }
        return map.get(keyOrder.get(index + 1));
    }

    // 判断当前键是否对应最后一个条目
    public boolean isLast(K currentKey) {
        int index = keyOrder.indexOf(currentKey);
        return index != -1 && index == keyOrder.size() - 1;
    }

    // 获取最后一个实体
    public V getLast() {
        if (keyOrder.isEmpty()) {
            return null;
        }
        return map.get(keyOrder.get(keyOrder.size() - 1));
    }

    // 其他常用Map方法，直接委托给内部map即可
    public V get(K key) {
        return map.get(key);
    }

    public boolean containsKey(K key) {
        return map.containsKey(key);
    }
}

注意事项 #

• 线程安全：如果是多线程环境，要给put、remove、导航方法加上同步锁，或者改用ConcurrentLinkedHashMap（若可用）+ 线程安全列表（比如CopyOnWriteArrayList），避免并发修改导致的不一致。
• 性能优化：keyOrder.indexOf(currentKey)是O(n)操作，如果Map条目数量极大（比如上万条），频繁调用导航方法会有性能瓶颈。这时可以额外维护一个Map<K, Integer>存储键对应的索引，把查找索引的复杂度降到O(1)，但要注意在put/remove时同步更新这个索引Map。

关于LinkedHashMap链式结构的补充 #

LinkedHashMap内部确实用双向链表维护了插入顺序，但链表节点的before、after引用是包私有访问权限的，外部无法直接调用。虽然可以通过反射强行获取，但这种做法非常不推荐——JDK内部实现可能随版本变更，会导致代码不稳定、兼容性差，所以还是上面两种方案更稳妥。

内容的提问来源于stack exchange，提问作者McMill