Java集合源码剖析之HashMap

最新推荐文章于 2020-04-21 15:23:40 发布

JavaBigData1024

最新推荐文章于 2020-04-21 15:23:40 发布

阅读量202

点赞数

分类专栏：源码阅读文章标签： Java HashMap 源码

本文链接：https://blog.csdn.net/weixin_44516305/article/details/88997347

版权

源码阅读专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Java集合源码剖析之HashMap

1 HashMap概括
2 HashMap源码剖析

1 HashMap概括

1.1 特性

HashMap存储的元素都是<key, value>键值对，它的容量可以动态的增长，其内部是通过单链表解决冲突问题。

HashMap是非线程安全的，只能在单线程环境下使用，多线程环境下可以采用concurrent并发包下的concurrentHashMap。

HashMap中元素的key不能重复，但value能重复，且key和value都可以为null值，如果key为null，则该键值对保存在数组下标为0那个位置所保存的单链表或红黑树中。

特性总结：无序、非线程安全、key不可重复、value可重复。

1.2 数据结构

HashMap中每一个<key, value>键值对元素都保存在一个节点中，节点的结构如下图所示：
在这里插入图片描述
HashMap使用的数据结构与JDK版本有关，在JDK1.8以前，HashMap是基于数组和单链表实现的，而在JDK1.8及以后版本，是基于数组和单链表和红黑树实现的。

在JDK1.8版本以前，HashMap的结构如下图所示：
在这里插入图片描述
在JDK1.8及以后版本，HashMap的数据结构如下图所示：

1.3 原理

HashMap中有两个属性影响其性能：

初始容量：HashMap中的用于存储首节点的数组（即table）的容量。
加载因子：HashMap中存储的元素的满的程度，默认为0.75。

HashMap中还有一个重要属性：

数组中实际元素个数的阀值：超过阀值就会考虑是否要对数组进行扩容。

1）数组：table
table数组用于存储首节点（链表首节点或红黑树首节点）。数据元素根据其hash值（根据key计算而得到的）散列到table数组中的不同位置，从而使得HashMap中的数据元素尽可能的均匀分布，可以提高HashMap的性能。多个不同的数据元素根据hash值可能散列到table数组中相同的位置，由于数组中每个位置只能存储一个数据元素，所以会产生冲突。因此，HashMap使用链表散列来解决冲突，即table数组中每一个位置存储的都是一个单链表的首节点，这样不同的数据元素即便是散列到table数组中相同的位置，也可以全部都添加到该位置对应的单链表中，从而解决冲突。

2）数组容量：capacity
capacity是table数组的容量，即数组的长度，默认值是16，最大值是1<< 30。正常情况下，第一次扩容到64，之后扩容到2倍。

3）实际大小：size
size就是HashMap中实际存储的数据元素的个数。

4）加载因子：loadFactor

loadFactor反应的是HashMap中元素的满的程度，loadFactor越趋近于1，HashMap中存储的元素也就越满（此时table数组中存放的数据也就越密，单链表的长度也越长），loadFactory越趋近于0，HashMap中存储的元素也就越稀（此时table数组中存储的数据也就越稀，单链表的长度也就越短）。把loadFactory设置得越大，单链表中的数据也就越多，这样会降低查找效率，因为通过key查找数据时，是先通过key的hash值找到table数组中的对应位置，再通过equals来比较该位置的单链表中的元素，如果单链表中的元素过多，那么查找的效率很低降低。把loadFactory设置得越小，这样虽然能让提高查找效率，但是数组中存放的数据太稀，会存在空间浪费的问题。所以HashMap中的loadFactor的初始值是0.75，一般情况不需要更改它。

计算公式：loadFactory = size / capacity

5）阀值：threshold
threshold是衡量table数组是否要进行扩容的阀值，当size>threshold时，就要考虑是否要对数组进行扩容了。注意这里说的是考虑，因为实际上对数组进行扩容，除了要求满足size>threshold条件之外，还要考虑扩容前和扩容后的容量这个条件。

计算公式：threshold = capacity * loadFactor

2 HashMap源码剖析

2.1 继承关系

HashMap的层次结构如下图所示：
在这里插入图片描述
HashMap的继承关系如下所示：

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
	......
}

2.2 元素节点

/**
 * 单链表元素节点
 */
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;
    }
}

/**
 * 红黑树元素节点
 */
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
	// 父节点
    TreeNode<K,V> parent;  // red-black tree links
    // 左孩子节点
    TreeNode<K,V> left;
    // 右孩子节点
    TreeNode<K,V> right;
    // 前一个节点
    TreeNode<K,V> prev;    // needed to unlink next upon deletion
    boolean red;
    TreeNode(int hash, K key, V val, Node<K,V> next) {
        super(hash, key, val, next);
    }
}

2.3 重要属性

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    private static final long serialVersionUID = 362498820763181265L;
    /**
     *  数组的默认初始容量
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 16

    /**
     * 数组的默认最大的容量
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * HashMap的默认装载因子
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * HashMap的实际装载因子
     */
    final float loadFactor;
    
    /**
     * 数组中元素的的阀值
     */
    int threshold;
    
    /**
     * 红黑树最小的容量
     */
    static final int MIN_TREEIFY_CAPACITY = 64;
    
    /**
     * 单链表转换成红黑树的阀值
     */
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * 红黑树转换成单链表的阀值
     */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * 存储首节点（单链表首节点或红黑树首节点）的数组，节点中存储的是数据元素
     */
    transient Node<K,V>[] table;

    /**
     * 存储key和value的实体集合
     */
    transient Set<Map.Entry<K,V>> entrySet;

    /**
     * HashMap中实际存储的元素的个数
     */
    transient int size;
}

2.4 构造方法

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {

    /**
     * 无参构造方法：使用数组的默认装载因子
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
    }
    
    /**
     * 有参构造方法：指定数组的初始容量，但使用数组的默认装载因子
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    
    /**
     * 有参构造方法：指定数组的初始容量和装载因子
     */
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
        }
        if (initialCapacity > MAXIMUM_CAPACITY) {
            initialCapacity = MAXIMUM_CAPACITY;
        }
        if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
        }
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

    /**
     * 有参构造方法：指定添加的元素
     */
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }
	
    /**
     * 根据容量计算数组的阀值
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }
}

2.5 核心方法

2.5.1 添加元素

/**
 * 添加单个<key, value>:如果存在该key的节点，如果节点有值，则覆盖
 */
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

/**
 * 添加单个<key, value>:如果存在该key的节点，如果节点有值，则不覆盖
 */
public V putIfAbsent(K key, V value) {
    return putVal(hash(key), key, value, true, true);
}

/**
 * 批量添加多个<key, value>
 */
public void putAll(Map<? extends K, ? extends V> m) {
    putMapEntries(m, true);
}

/**
 * 根据key计算对应的hash
 */
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

/**
 * 往HashMap中添加一个<key, value>
 */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; 
    Node<K,V> p; 
    int n, i;
    // 如果HashMap中存储首节点的数组为null，则实例化数组
    if ((tab = table) == null || (n = tab.length) == 0) {
        n = (tab = resize()).length;
    }
    // 根据hash值计算应该存储到数组中的哪个位置
    if ((p = tab[i = (n - 1) & hash]) == null) {
    	// 如果数组中该位置为空，则直接把<key, value>存储到该位置上
        tab[i] = newNode(hash, key, value, null);
    }
    else {
    	// 如果数组中该位置不为空，则查找合适的存储位置
        Node<K,V> e; K k;
        // 如果数组中该位置上存储的元素的key即为该key
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) {
            // 则数组中该位置即为存储的位置
            e = p;
        }
        // 如果数组中该位置上存储的元素的key不是该key，且存储的节点是红黑树节点，则将想要添加的<key, value>添加到红黑树上
        else if (p instanceof TreeNode) {
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        }
        // 如果数组中该位置上存储的元素的key不是该key，且存储的节点是单链表节点
        else {
        	// 遍历单链表，查找合适的存储位置
            for (int binCount = 0; ; ++binCount) {
                // 如果遍历到了单链表的末尾，都不存在与该key相同的元素节点
                if ((e = p.next) == null) {
                	// 直接在单链表的末尾添加一个新节点，并把该<key, value>存储在新创建的节点中
                    p.next = newNode(hash, key, value, null);
                    // 检查是否要把单链表转化成红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) {
                        treeifyBin(tab, hash);
                    }
                    break;
                }
                // 如果当前遍历的节点中存储的元素的key即为该Key，则当前节点即为存储的位置
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
                    break;
                }
                p = e;
            }
        }
        // 如果在单链表中找到了与该key相同的节点，则更新该节点的value为新的value
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            // 如果该节点为的value不为null，则根据onlyIfAbsent来判断是否要使用新value覆盖原来的value
            // 如果该节点的value为null，则直接设置该节点的value为新的value
            if (!onlyIfAbsent || oldValue == null) {
                e.value = value;
            }
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 修改实际存储的元素的个数，并检查是否要进行扩容
    if (++size > threshold) {
        resize();
    }
    afterNodeInsertion(evict);
    return null;
}

/**
 * 往HashMap中添加多个Entry
 */
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    // 获取要添加的元素的个数
    int s = m.size();
    if (s > 0) {
    	// 如果HashMap中存储首节点的数组为null，则先对数组进行初始化
        if (table == null) { // pre-size
        	// 计算在默认参数的情况下添加了所有的元素之后的HashMap的容量
            float ft = ((float)s / loadFactor) + 1.0F;
            // 把添加之后的容与默认的最大容量进行对比，决定添加之后的HashMap的容量
            int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY);
            // 如果添加之后的容量超过了默认的阀值，则重新设置阀值
            if (t > threshold) {
                threshold = tableSizeFor(t);
            }
        }
        // 如果HashMap中存储单链表首节点的数组不为null，且要添加的元素的个数超过了HashMap的容量，则先进行扩容
        else if (s > threshold) {
            resize();
        }
        // 逐个添加元素到HashMap中
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
            K key = e.getKey();
            V value = e.getValue();
            putVal(hash(key), key, value, false, evict);
        }
    }
}

2.5.2 查询元素

/**
 * 获取指定key的元素
 */
public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

/**
 * 获取指定key的元素，如果不存在符合条件的元素，则返回默认值
 */
public V getOrDefault(Object key, V defaultValue) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
}

/**
 * 从HashMap中获取指定key的节点
 */
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // 如果HashMap中存储首节点的数组不为空，且该key映射到数组中的相应位置存储的首节点不为null
    if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
    	// 如果首节点的key即为要查找的key，则直接返回首节点
        if (first.hash == hash &&  ((k = first.key) == key || (key != null && key.equals(k)))) {
            return first;
        }
        // 如果首节点的key不是要查找的key，则继续查找
        if ((e = first.next) != null) {
        	// 如果首节点是红黑树节点，则在红黑树中查找并返回
            if (first instanceof TreeNode) {
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            }
            // 如果首节点是单链表节点，则遍历单链表查找  
            do {
            	// 如果当前节点的key即为要查找的key，则当前节点即为要查找的节点
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
                    return e;
                }
            } while ((e = e.next) != null);
        }
    }
    return null;
}

2.5.3 修改元素

/**
 * 如果存在指定key的元素，则修改其值
 */
public V replace(K key, V value) {
    Node<K,V> e;
    if ((e = getNode(hash(key), key)) != null) {
        V oldValue = e.value;
        e.value = value;
        afterNodeAccess(e);
        return oldValue;
    }
    return null;
}

/**
 * 如果存在指定key且指定value的元素，则使用新value替换旧的value
 */
public boolean replace(K key, V oldValue, V newValue) {
    Node<K,V> e; V v;
    if ((e = getNode(hash(key), key)) != null && ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
        e.value = newValue;
        afterNodeAccess(e);
        return true;
    }
    return false;
}

2.5.4 删除元素

/**
 * 删除指定key的元素
 */
public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value;
}

/**
 * 删除指定key和value的元素
 */
public boolean remove(Object key, Object value) {
    return removeNode(hash(key), key, value, true, true) != null;
}

/**
 * 清空
 */
public void clear() {
    Node<K,V>[] tab;
    modCount++;
    if ((tab = table) != null && size > 0) {
        size = 0;
        for (int i = 0; i < tab.length; ++i) {
            tab[i] = null;
        }
    }
}

/**
 * 从HashMap中删除一个节点
 */
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;
    
    // 如果HashMap中存储首节点的数组不为空，且该key映射到数组中相应位置存储的首节点不为null
    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;
        // 如果该首节点的key即为了要删除的key，则首节点即可能为要删除的节点
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) {
            node = p;
        }
        // 如果该首节点的key不是要删除的key，则继续查找要删除的节点
        else if ((e = p.next) != null) {
        	//  如果首节点是红黑树节点，则在红黑树中查找要删除的节点
            if (p instanceof TreeNode) {
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            }
            //  如果首节点是单链表节点，则在单链表中查找要删除的节点    
            else {
            	// 遍历单链表中的节点
                do {
                	// 如果当前节点的key即为要删除的节点的key，则当前节点即可能为要删除的节点
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        // 如果找到了指定key的节点，则根据是否还要求value也匹配来决定是否要删除该节点，如果满足所有条件则删除该节点
        if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) {
            // 如果该节点为红黑树节点，则从红黑树中删除该节点
            if (node instanceof TreeNode) {
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            }
            // 如果该节点为单链表节点，且该节点为首节点，则直接设置新的单链表首节点
            else if (node == p) {
                tab[index] = node.next;
            }
            // 如果该节点为单链表节点，但不是首节点，则删除该节点
            else {
                p.next = node.next;
            }
            ++modCount;
            // 修改实际存储的元素的个数
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

2.5.5 数组扩容

HashMap是基于数组和单链表和红黑树实现的，由于单链表和红黑树的容量本来就可以动态的增减，所以HashMap的扩容是针对于用于存储首节点的数组而言的，数组的创建和扩容都是由同一个方法完成的，具体代码如下所示：

/**
 * 数组的创建和扩容
 */
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    // 旧的容量
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 旧的阀值
    int oldThr = threshold;
    // 新的容量和阀值
    int newCap, newThr = 0;
    
    // 如果旧的容量大于0
    if (oldCap > 0) {
    	// 如果旧的容量不低于允许的最大容量，则只修改阀值而不进行扩容
        if (oldCap >= MAXIMUM_CAPACITY) {
        	// 设置阀值为最大值
            threshold = Integer.MAX_VALUE;
            // 不进行扩容，直接返回旧的数组
            return oldTab;
        }
        // 如果旧容量的2倍要比允许的最大容量要小，且旧的容量不小于默认的初始容量，则扩容后的容量为原来的2倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) {
            // 扩容后的阀值也为原来的2倍
            newThr = oldThr << 1;
        }
    }
    // 如果旧的容量为0，但旧的阀值大于0
    else if (oldThr > 0) {
   		// 则新容量等于旧的阀值
        newCap = oldThr;
    }
    // 如果旧的容量为0，且旧的阀值也为0
    else {
    	// 新的容量为默认初始容量
        newCap = DEFAULT_INITIAL_CAPACITY;
        // 新的阀值则根据默认加载因子和默认初始容量计算而得
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 如果新的阀值为0
    if (newThr == 0) {
    	// 则根据扩容后的容量和加载因子计算重新计算扩容后的阀值
        float ft = (float)newCap * loadFactor;
        // 如果扩容后的新的容量和重新计算得到的扩容后的阀值都要比允许的最大值要小，则扩容后的容量为重新计算后的容量，否则为最大值
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
    }
    // 设置扩容后的阀值
    threshold = newThr;
    // 根据扩容后的容量创建一个更大的数组
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    // 如果旧的数组不为null，则要把旧的数组中的元素全部重新散列到扩容后的数组中
    if (oldTab != null) {
   		// 遍历旧数组
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            // 如果旧数组中当前位置存储的首节点不为null
            if ((e = oldTab[j]) != null) {
            	// 清空数组中的当前位置
                oldTab[j] = null;
                // 如果当前首节点没有后继节点
                if (e.next == null) {
                	// 则直接把当前头节点散列到新的数组中
                    newTab[e.hash & (newCap - 1)] = e;
                }
                // 如果当前首节点有后继节点，且当前首节点是红黑树节点
                else if (e instanceof TreeNode) {
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                }
                // 如果当前首节点有后继节点，且当前首节点是单链表节点
                else {
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    // 遍历单链表中的每一个节点，把原来的单链表散列成为两个新的单链表
                    do {
                        next = e.next;
                        // 满足该条件的节点全部都添加到低位置的单链表上
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null) {
                                loHead = e;
                            }
                            else {
                                loTail.next = e;
                            }
                            loTail = e;
                        }
                        // 满足该条件的节点全部都添加到高位置的单链表上
                        else {
                            if (hiTail == null) {
                                hiHead = e;
                            }
                            else {
                                hiTail.next = e;
                            }
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 如果低位置的单链表不为null，则把低位置的单链表的首节点存储到扩容后的数组的对应低位置上
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 如果高位置的单链表不为null，则把高位置的单链表的首节点存储到扩容后的数组的对应高位置上
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

扩容总结：正常情况下扩容为原来的2倍，阀值也扩为原来的2倍

2.5.6 其它方法

/**
 * 判断HashMap中是否包含指定的key
 */
public boolean containsKey(Object key) {
    return getNode(hash(key), key) != null;
}

/**
 * 判断HashMap中是否包含指定value
 */
public boolean containsValue(Object value) {
    Node<K,V>[] tab; V v;
    if ((tab = table) != null && size > 0) {
    	// 遍历存储首节点的数组
        for (int i = 0; i < tab.length; ++i) {
        	// 如果首节点不为null，则遍历首节点所对应的单链表中所有的节点
            for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                if ((v = e.value) == value || (value != null && value.equals(v)))
                    return true;
            }
        }
    }
    return false;
}

/**
 * 获取HashMap中所有的key
 */
public Set<K> keySet() {
	Set<K> ks = keySet;
	if (ks == null) {
	    ks = new KeySet();
	    keySet = ks;
	}
	return ks;
}

/**
 * 获取HashMap中所有的value
 */
public Collection<V> values() {
    Collection<V> vs = values;
    if (vs == null) {
        vs = new Values();
        values = vs;
    }
    return vs;
}

/**
 * 获取HashMap中所有的Entry
 */
public Set<Map.Entry<K,V>> entrySet() {
    Set<Map.Entry<K,V>> es;
    return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}