HashMap源码解读

1. HashMap 结构

HashMap 基于数组的形式存储节点，出现hash冲突后，以链表的形式存储元素。当链表的长度>8时，裂变为红黑树。

2. 重要字段

transient Node<K,V>[] table; Hash表结构transient int size; 元素个数,K,V个数int threshold; 下一次增容前的阈值。 超过将会扩容final float loadFactor; 加载因子threshold = size * loadFactorcapacity : HashMap中桶的数量。static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认初始容量static final int MAXIMUM_CAPACITY = 1 << 30; 最大容量static final float DEFAULT_LOAD_FACTOR = 0.75f; 默认加载因子static final int TREEIFY_THRESHOLD = 8; 链表转红黑树的阈值

2.1 补充

前提知识：

HashMap 是 一种 Map ，使用 HashCode 进行索引等相关操作，所以叫 HashMapHashCode 是一个 native 方法 ，详见 java.lang.Object#hashcode()不同的 JVM 对 native 方法 有不同的实现。

---

因此，当一个 HashMap 序列化后，被另外一个(不同的) JVM 进行反序列化时：

由于不同的JVM 的 HashCode 的策略有所不同，使用原来 JVM 上计算的 HashCode 值在另外一个 JVM 上计算会引起错误。

---

所以，如果要序列化一个 HashMap ，需要剔除 hashcode 的影响，所以属性标识成了 transient 类型。

3. 常用方法

3.1 构造方法

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(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); }

主要是完成容量和加载因子的赋值。采用懒加载的方式，只有第一次插入数据时才会被赋值。

3.2 put

public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) { // hashmap的表 HashMap.Node<K, V>[] tab; // hashmap的节点 HashMap.Node<K, V> p; int n, i; // 第一次put的时候，分配空间 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; // 如果哈希表中K对应的位置为空，那么该KV 就是头结点 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { HashMap.Node<K, V> e; K k; // 出现hash冲突 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; // 如果是p是树节点，红黑树的形式 else if (p instanceof HashMap.TreeNode) e = ((HashMap.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; } // 若hash相等，值也相等，退出循环 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; } } // 记录hashmap 修改的次数 ++modCount; // 若hashmap大小超过阈值，需要resize if (++size > threshold) resize(); // 子类实现 afterNodeInsertion(evict); return null; }

3.3 get

public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } /** * Implements Map.get and related methods * * @param hash hash for key * @param key the key * @return the node, or null if none */ final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; // 根据hash确定桶的位置 if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { // 查看桶中的第一个元素是否符合 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; // 若桶的第一个不符合 if ((e = first.next) != null) { // 去红黑树里面查找 if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key); // 遍历列表查找 do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }

3.4 resize

final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; // 旧tab的容量 int oldCap = (oldTab == null) ? 0 : oldTab.length; // 旧tab的阈值 int oldThr = threshold; int newCap, newThr = 0; // 旧tab存在 if (oldCap > 0) { // 若旧tab容量已达到最大值，放弃扩容 if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } // 新的容量 = 旧容量 * 2 // 若新容量 小于最大的容量且大于初始容量 // 更新 threshold else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } // 如果阈值大于0，说明构造方法里面指定了阈值 else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; // 若没有指定阈值，使用默认的 else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } 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; // 若旧的tab不为null if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { Node<K,V> e; // 旧tab中的元素不为null。将其置为null，方便回收 if ((e = oldTab[j]) != null) { oldTab[j] = null; // 若桶中只有一个元素 if (e.next == null) newTab[e.hash & (newCap - 1)] = e; // 若节点为TreeNode else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // preserve order // 前半截 Node<K,V> loHead = null, loTail = null; // 后半截 Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; // 判断元素是否需要移动位置 // 示例1： // e.hash=10 0000 1010 // oldCap=16 0001 0000 // & =0 0000 0000 比较高位的第一位 0 //结论：元素位置在扩容后数组中的位置没有发生改变 if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } // 示例2： // e.hash=17 0001 0001 // oldCap=16 0001 0000 // & =1 0001 0000 比较高位的第一位 1 //结论：元素位置在扩容后数组中的位置发生了改变，新的下标位置是原下标位 置+原数组长度 else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); if (loTail != null) { loTail.next = null; newTab[j] = loHead; } if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }

3.5 remove

public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; } 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; //找到要remove的元素 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); else { do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null); } } 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; // 大小减1 --size; // 子类实现 afterNodeRemoval(node); return node; } } return null; }