Java 集合框架（6）---- Map 相关类解析（下）

本文标题大纲：

前言

在上上篇文章中，我们看了一下 Java 集合框架中一些 Map 接口下的具体类，主要是对 HashMap 和 TreeMap 实现原理和相关元素操作流程的源码解析。接下来这篇文章中我们继续来解析 Java 集合框架中 Map 接口下的另一些具体类。Ok，话不多说，进入正题，还是先看图：

在这里列举的 Map 接口我们还剩下三个类没看，但是除了这张图里列举的 Map 具体类，还有一个比较常用的 Map 接口下的具体类：LinkedHashMap。我们就先从这个类开始：

LinkedHashMap

回想我们使用 HashMap 时，元素的遍历顺序和插入顺序是不一定相同的，通过前篇的源码解读我们也知道了原因：HashMap 内部使用键值对数组来储存元素，对于每一个键值对，其在数组中的下标完全取决于其键的哈希值（hashCode），而我们在通过迭代器遍历 HashMap 的时候实际上相当于顺序遍历其内部的元素储存数组。那么如果我们需要使得元素的遍历顺序和插入顺序相同时 HashMap 就不能很好的实现这个功能了。这个时候就可以通过 LinkedHashMap 来完成这个功能。下面我们一起来看看这个类：

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V> {
   
   
    /**
     * LinkedHashMap 中表示键值对元素节点的类，继承于 HashMap.Node
     */
    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);
        }
    }

    // 和序列化和反序列化有关，暂时不管
    private static final long serialVersionUID = 3801124242820219131L;

    /**
     *  LinkedHashMap 中双向链表的头结点（首元结点）
     */
    transient LinkedHashMap.Entry<K,V> head;

    /**
     * LinkedHashMap 中双向链表的尾节点
     */
    transient LinkedHashMap.Entry<K,V> tail;

    /**
     * 链表元素的排序依据：按访问顺序排序（true），按插入顺序排序（false）
     */
    final boolean accessOrder;
	// ...
}

从这里我们大概可以知道了，LinkedHashMap 内部通过双向链表来维持元素的顺序，同时其继承于 HashMap ，因此可以猜测 LinkedHashMap 的一些操作时复用父类的。而查看 LinkedHashMap 的结构，发现很多对元素的操作方法都没有直接提供：

可以看到，类似于 put 和 remove 方法都没有在 LinkedHashMap 中提供，但是我们在使用 LinkedHashMap 的时候都是直接使用这些方法来操作元素，那么很显然其是复用了父类（HashMap） 的相关方法。如此一来，新的问题又产生了：HashMap 本身在操作元素（插入、删除）时候是并没有考虑元素的插入顺序的，其是通过要插入的键值对元素的键的 hashCode （哈希值）来决定元素的插入位置，那么 LinkedHashMap 是怎么实现元素访问顺序和插入顺序相同的功能呢？

操作元素

对于上面的问题，我们还是看看 HashMap 的源码：

// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) {
   
    }
void afterNodeInsertion(boolean evict) {
   
    }
void afterNodeRemoval(Node<K,V> p) {
   
    }

可以发现，HashMap 中提供了 3 个方法供 LinkedHashMap 重写，在 HashMap 的 putVal（HashMap 的 put 方法中会调用）方法中还会调用 newNode 和 newTreeNode 方法，我们来看看：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
   
   
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        // ！！这里
        tab[i] = newNode(hash, key, value, null);
    else {
   
   
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            // 如果是树节点，那么创建 TreeNode
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
   
   
            for (int binCount = 0; ; ++binCount) {
   
   
                if ((e = p.next) == null) {
   
   
                    // ！！这里
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) {
   
    // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    // ...

在上述源码中：

// 如果是树节点，那么创建 TreeNode
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

putTreeVal 方法中会调用 newTreeNode 方法，显然，这两个方法（newNode、newTreeNode）都是用来新建键值对元素的，关于上述流程如果小伙伴们还不清楚，可以参考我的上上篇文章：Java 集合框架(5)---- Map 相关类解析(中) 中对 HashMap 的介绍。而对于这 5 个方法，LinkedHashMap 中也对他们进行了重写：

顺便提一下，这 5 个方法在 HashMap 中都是默认修饰符的，我们知道，默认修饰符的属性只能被同一个类文件或者同一个包中的其他类访问，子类是没办法访问的（没有可见性），这里 LinkedHashMap 是 HashMap 的子类，从这个角度上来说，其是没有对这 5 个方法的访问权的（可以理解为它根本看不到父类的这 5 个方法），但是它还有另外一重身份：和 HashMap 同包（HashMap 和 LinkedHashMap 都是在 java.utl 包中），因此从这方面来说，其可以对这 5 个方法进行重写。那么我们看一下这 5 个在 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;
}

这个方法新建的是 LinkedHashMap 提供的表示双向链表节点的类对象，之后调用了 linkNodeLast 方法来连接这个新建的链表元素，不用看我们也知道这个方法将新建的节点连接到链表尾部：

// link at the end of list
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
   
   
    LinkedHashMap.Entry<K,V> last = tail;
    tail = p;
    // 如果当前链表的尾节点为 null，证明当前链表还没有元素，
    // 因此将 head 赋值为 p，这里换成 head == null 判断也可以，写法不同而已。
    if (last == null)
        head = p;
    else {
   
   
        p.before = last;
        last.after = p;
    }
}

这样一来在调用 LinkedHashMap 的 puut 方法（实际上调用的是 HashMap 的 put 方法）时 LinkedHashMap 就可以初步保证元素的顺序和插入顺序是相同的（put -> putVal -> newNode -> linkNodeLast），为什么是初步保证？因为能改变链表的还有删除元素的操作呀。那么我们来看看 HashMap 的 remove 方法：

public V remove(Object key) {
   
   
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

可以看到，直接调用了 removeNode 方法：

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
   
   
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
   
   
        Node<K,V> node = null, e; K k; V v;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
   
   
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);