前言

Java 集合可分为Collection 和Map 两种体系:

• Collection接口：单列数据，定义了存取一组对象的方法的集合
  • List：元素有序、可重复的集合
    • ArrayList、LinkedList、Vector
  • Set：元素无序、不可重复的集合
    • HashSet、LinkedHashSet、TreeSet
• Map接口：双列数据，保存具有映射关系“key-value对”的集合，也称为键值对。
  • HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

现在我们开始学习LinkedHashMap。

概述

• LinkedHashMap是HashMap的子类
• 在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序
• 与LinkedHashSet类似，LinkedHashMap可以维护Map 的迭代顺序：迭代顺序与Key-Value 对的插入顺序一致

底层

HashMap中的内部类：Node

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }

    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

LinkedHashMap中的内部类：Entry

static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after;
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}

LinkedHashMap的底层是Entry，继承了父类HashMap中的Node节点，并且还多出几个属性

• before，指向前一个元素。
• after，指向后一个元素。

而且还有记录首尾元素的属性：

transient LinkedHashMap.Entry<K,V> head;

transient LinkedHashMap.Entry<K,V> tail;

添加元素

LinkedHashMap添加元素也是调用父类的put方法，但是在节点处理时，重写了节点的方法。

• LinkedHashMap.newNode()

Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
    LinkedHashMap.Entry<K,V> p =
        new LinkedHashMap.Entry<K,V>(hash, key, value, e);
    linkNodeLast(p);
    return p;
}

private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
    LinkedHashMap.Entry<K,V> last = tail;
    tail = p;
    if (last == null)
        head = p;
    else {
        p.before = last;
        last.after = p;
    }
}

看到这里，想必你已经明白，用before和after来记录前后元素，head和tail来记录首尾元素。

那么它的原理与HashMap差不多，只是节点处理上有点不一样。