集合系列 Map(十三):LinkedHashMap

我们之前说过 LinkedHashMap 是在 HashMap 的基础上,增加了对插入元素的链表维护。那么其到底是怎么实现的呢?今天这篇文章就带我们来一探究竟。

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

LinkedHashMap 的声明比较简单,继承了 HashMap 类,实现了 Map 接口。

原理

我们将从类成员变量、构造方法、核心方法、扩容机制几个方向介绍 HashMap 的原理。

类成员变量

// 链表头节点
transient LinkedHashMap.Entry<K,V> head;
// 链表尾节点
transient LinkedHashMap.Entry<K,V> tail;
// 通过iterator访问时的顺序,true表示按照访问顺序,false表示按照插入顺序。
final boolean accessOrder;

可以看到在 LinkedHashMap 的类成员变量中增加了 head 和 tail 两个变量,从而实现了对插入元素的链表维护。而这里的 accessOrder 则表示遍历 LinkedHashMap 时将按照什么顺序输出,这里我们先留意一下有 accessOrder 这个参数,后续会讲到。

构造方法

LinkedHashMap 一共有 5 个构造方法:

public LinkedHashMap() {
    super();
    accessOrder = false;
}

public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
    accessOrder = false;
}

public LinkedHashMap(int initialCapacity,
                     float loadFactor,
                     boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}
    
public LinkedHashMap(Map<? extends K, ? extends V> m) {
    super();
    accessOrder = false;
    putMapEntries(m, false);
}

构造方法基本上是进行了一些类成员变量的参数设置,没有什么难懂的地方。

核心方法

LinkedHashMap 的核心方法主要有:get、put、remove、遍历。

get

LinkedHashMap 的 get 方法实现如下:

public V get(Object key) {
    Node<K,V> e;
    if ((e = getNode(hash(key), key)) == null)
        return null;
    if (accessOrder)
        afterNodeAccess(e);
    return e.value;
}

可以看到,其直接调用了 HashMap 的 getNode 方法获取到对应的节点。但这里有一个细节需要注意:

if (accessOrder)
    afterNodeAccess(e);

这里如果我们设置了 accessOrder 为 true,那么就执行 afterNodeAccess 方法。我们继续看看这个方法做了什么。

// 将节点挪到链表尾部
void afterNodeAccess(Node<K,V> e) { 
    LinkedHashMap.Entry<K,V> last;
    // 如果 accessOrder 为true,且尾部节点不是 e 节点,那么将其挪到尾部
    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;
    }
}

其实 afterNodeAccess 方法的作用就是将我们访问到的 e 节点挪到链表尾部。还记得我们之前说到 accessOrder 变量的作用么?

// 通过iterator访问时的顺序,true表示按照访问顺序,false表示按照插入顺序。
final boolean accessOrder;

如果 accessOrder 为 true,那么表示访问时就要按照访问顺序去访问。而在 get 方法中,我们每访问一个节点,我们就会将该节点放入链表尾部,所以我们通过 iterator 访问链表时就是按照访问顺序得到的遍历(越早访问的越在后面)。

put

我们会发现 LinkedHashMap 中并没有 put 方法的实现,这是因为其直接使用了 HashMap 的 put 方法实现。

remove

LinkedHashMap 中也没有 remove 方法的实现,也是直接使用了 HashMap 的 remove 方法实现。

遍历

在将 LinkedHashMap 的遍历之前,我们先用一个例子回顾一下 LinkedHashMap 的遍历过程。

Map<String, String> hashMap = new LinkedHashMap<>();
hashMap.put("name", "tom");
hashMap.put("age", "27");
hashMap.put("address", "guangdong");
Iterator<String> iterator = hashMap.keySet().iterator();
while (iterator.hasNext()) {
    // name,age,address
    String key = iterator.next();
    System.out.println(key + "," + hashMap.get(key));
}

上面的代码输出之后是:name、age、address,其按照插入顺序访问。但如果是 HashMap 的话,那么结果是:address、name、age。要弄清楚为什么那么我们就必须看看其源码是如何实现的。我们先进入 hashMap.keySet().iterator() 这块的代码看看,即 LinkedHashMap.keySet 方法:

public Set<K> keySet() {
    Set<K> ks = keySet;
    if (ks == null) {
        ks = new LinkedKeySet();
        keySet = ks;
    }
    return ks;
}

可以看到其返回的是一个 LinkedKeySet 对象,我们继续看看 LinkedKeySet 对象的代码。

final class LinkedKeySet extends AbstractSet<K> {
    // 省略其他方法
    public final Iterator<K> iterator() {
        return new LinkedKeyIterator();
    }
    // ...省略其他方法

上面的代码很多,但我们只需要关心 iterator 方法就可以了,因为我们调用了 keySet 方法之后就调用了 iterator 方法。我们可以看到 iterator 方法返回了一个 LinkedKeyIterator 对象。

我们知道我们获取到了 Iterator 对象之后会调用两个方法,即:hasNext 方法和 next 方法。LinkedKeyIterator 类继承了 LinkedHashIterator,其 hasNext 方法调用了父类的实现,但其 next 方法则是自己实现了。

final class LinkedKeyIterator extends LinkedHashIterator
    implements Iterator<K> {
    public final K next() { return nextNode().getKey(); }
}

所以如果要弄清楚其访问顺序,我们需要看看其 nextNode 方法的实现。

// LinkedHashIterator.nextNode
final LinkedHashMap.Entry<K,V> nextNode() {
    // 将下个节点赋值给 e 
    LinkedHashMap.Entry<K,V> e = next;
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    if (e == null)
        throw new NoSuchElementException();
    current = e;
    // 更新 next 属性
    next = e.after;
    return e;
}

从上面的方法我们可以看到其把 next 节点直接赋值给 e 并返回。而每一次进行 nextNode 操作都会更新 next 属性到下一个节点。我们从构造方法可以看到 LinkedHashIterator 的构造方法可以看到,next 节点首次赋值是指向了头结点。

LinkedHashIterator() {
    next = head;
    expectedModCount = modCount;
    current = null;
}

到了这里遍历的顺序就一目了然了。首先从头结点开始遍历,一直遍历到尾节点。而链表的顺序则是我们一直在维护的。默认情况下按照插入顺序排列,如果设置了 accessOrder,那么就按照访问顺序排列。每次访问到一个节点,就将其放到尾部。所以如果设置 accessOrder 为 true,那么越近访问到的节点就会越慢访问到。

总结

LinkedHashMap 相对于 HashMap 维护了一个插入元素的顺序,但其大部分的实现都直接调用了 HashMap 的实现。所以相对于 HashMap 来说,LinkedHashMap 还是比较好理解的。

  • LinkedHashMap 继承了 HashMap,直接调用了 HashMap 的实现。
  • LinkedHashMap 维护了插入元素的顺序,可以根据 accessOrder 来设定是按照访问顺序遍历,还是按照插入顺序遍历。
posted @ 2019-08-28 21:13  陈树义  阅读(...)  评论(... 编辑 收藏