java集合框架（三）：LinkedHashMap

开发十年，就只剩下这套架构体系了！ >>>   

        LinkedHashMap的数据结构跟HashMap类似，只是在节点上多加了指向前和向后的两个属性，也可以概括为：数组+链表（双向）+红黑树（java8增加了红黑树），如下图所示：

    

一、类的定义

public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>
{}

二、存储单元

        LinkedHashMap的基本存储单元也是继承HashMap的存储单元，新增了两个节点属性，一个指向前，一个向后。

// 定义在LinkedHashMap类中
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);
        }
}

// 定义在HashMap类中
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;
        }
}

三、构造函数

        构造函数主要是初始化父类的属性值，LinkedHashMap新增的就只有一个：

boolean accessOrder = false;// 链表是否按照节点访问顺序排序，true：是，false：否。它起到什么作用，我在文章后面会解析。

public LinkedHashMap() {
        // 调用父类构造器
        super();
        accessOrder = false;
}

// 指定初始容量
public LinkedHashMap(int initialCapacity) {
        super(initialCapacity);
        accessOrder = false;
}

// 指定初始容量和负载因子（负载因子一般使用默认的）
public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        accessOrder = false;
}

// 指定初始容量，负载因子，是否按访问顺序排序
public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
}

// 可以把其他map的元素加载进来
public LinkedHashMap(Map<? extends K, ? extends V> m) {}

四、双向链表的构造

        LinkedHashMap构建双向链表是通过重写父类HashMap的方法newNode(int hash, K key, V value, Node<K,V> e)实现的。当往LinkedHashMap中插入新节点的时候，其直接调用父类HashMap的put方法，put方法生产新节点的时候会调用newNode方法。

        来看看重写之后的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;
        // 如果尾节点为空，说明p是头节点
        if (last == null)
            head = p;
        else {
            // 前后节点的链接
            p.before = last;
            last.after = p;
        }
}

五、遍历实现

        LinkedHashMap的遍历是通过LinkedHashIterator抽象类实现的，它从双向链表的头节点开始遍历，直到链表的尾部。

abstract class LinkedHashIterator {
        LinkedHashMap.Entry<K,V> next;
        LinkedHashMap.Entry<K,V> current;
        int expectedModCount;

        // 构造器初始化的时候把头节点传入
        LinkedHashIterator() {
            next = head;
            // fast-fail机制，遍历时避免节点被改变
            expectedModCount = modCount;
            current = null;
        }
        // 迭代器的hasNext()方法会调用该方法
        public final boolean hasNext() {
            return next != null;
        }
        // 迭代器的next()方法会调用该方法
        final LinkedHashMap.Entry<K,V> nextNode() {
            LinkedHashMap.Entry<K,V> e = next;
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (e == null)
                throw new NoSuchElementException();
            current = e;
            // 对下一个节点赋值
            next = e.after;
            return e;
        }
}

        对比LinkedHashMap与HashMap的遍历：

public static void main(String[] args) {
        Map<String,String> linkedHashMap = new LinkedHashMap<String, String>();
        linkedHashMap.put("NO1","小明");
        linkedHashMap.put("NO2","小赵");
        linkedHashMap.put("NO3","小周");

        System.out.println("----遍历LinkedHashMap----");
        for(Map.Entry entry:linkedHashMap.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }

        Map<String,String> hashMap = new HashMap<String, String>();
        hashMap.put("NO1","小明");
        hashMap.put("NO2","小赵");
        hashMap.put("NO3","小周");

        System.out.println("-----遍历HashMap-------");
        for(Map.Entry entry:hashMap.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
}

        测试结果：

        从上面的测试结果可以看出，LinkedHashMap确实可以对节点进行先进先出的排序。而HashMap的排序顺序是不确定的。

六、访问顺序排序

        文章开头讨论过属性accessOrder，它决定链表是否按节点访问的顺序排序，如果为true就是访问顺序排序，这时当某个存在的节点被操作过（比如被get（）方法调用过，或者值被替换过），那么先进先出的排序就会打乱，被访问的节点会被排到最后。看一个例子：

public static void main(String[] args) {
        // 指定accessOrder为true
        Map<String,String> linkedHashMap = new LinkedHashMap<String, String>(10,0.75f,true);
        linkedHashMap.put("NO1","小明");
        linkedHashMap.put("NO2","小赵");
        linkedHashMap.put("NO3","小周");
        // 对NO1进行get操作
        linkedHashMap.get("NO1");

        System.out.println("----按访问顺序遍历LinkedHashMap----");
        for(Map.Entry entry:linkedHashMap.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
}

        测试结果：

        访问排序的实现是在每个操作函数里面调用了方法afterNodeAccess，来看看它的实现：

void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        if (accessOrder && (last = tail) != e) {
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.after = null;
            // 以下操作主要把当前访问的节点移到链表的尾部
            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;
        }
}

七、总结

        LinkedHashMap在HashMap的基础上多维护了一条双向链表，其最重要特征就是可以对map进行先进先出的遍历操作，如有需要也可以对其按访问顺序遍历。

        以上就是我对LinkedHashMap的原理的理解，如有错误之处，请批评和指正。