JDK1.8中HashMap源码学习
这几天工作空闲下来，把部分HashMap源码模仿了一遍，仔细阅读了里面一些关键的方法。主要包含：字段解释，构造方法，tableSizeFor(), put(), resize()。我将阅读时碰到的问题和答案写在了代码注释中，感觉这样比较直观。如果有想学习HashMap源码的码友，可以参考。
package com.wdit.my.test; import java.util.Map; import java.util.Set; import javax.swing.tree.TreeNode; /** * 构造MyHashMap * * @author neal * @param <K> * @param <V> * */ public class MyHashMap<K, V> implements MyMap<K, V> { private static final int INIT_CAPACITY = 1 << 4; // 默认初始容量 （桶的数量，table数组的长度） HashMap的capacity都是2的幂，如何保证：构造函数，tableSizeFor(),put（），resize（）的系列操作 private static final float LOAD_FACTOR = 0.75f; // 默认初始加载因子。为什么是0.75？理想状态下哈希表的每个箱子中，元素的数量遵守泊松分布，当负载因子为 0.75 时，泊松公式中λ 约等于 0.5，
//通过公式计算链表中节点数量为8的概率几乎为0。也就是说用0.75作为加载因子，每个碰撞位置的链表长度超过８个是几乎不可能的。 private static final int MAX_CAPACITY = 1 << 30; // 最大容量,为什么不是2^31-1呢？overflow找到一个回答说，在2^30或者更低的范围来保证安全性，比2^31-1容易的多，没有必要追求极限。 private static final int TREEFY_THRESHOLD = 8; // 桶中的链表中节点数量大于等于8，链表可能会转化为红黑树，是否转化还需考察MIN_TREEFY_CAPACITY private static final int UNTREEFY_THRESHOLD = 6; // 当节点小于等于6，树退化为链表 private static final int MIN_TREEFY_CAPACITY = 64; // 链表转化为树前，还要判断，只有键值对（注意：不是桶的数量）大于64才会转换。防止哈希表建立初期，多个键值对刚好放入一个链表，导致不必要的转化； static class Node<K, V> implements Map.Entry<K, V> {// node bin final int hash; final K key; V value; Node<K, V> next; Node(int hash, K key, V value, Node<K, V> next) { super(); this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public V setValue(V newValue) { V oldValue = this.value; value = newValue; return oldValue; } } /*-------------------fileds 字段----------------*/ transient int size; // KV数量，（链表，树中的总和） transient int modCount;// map结构修改的次数，例如添加新Node。注意如果是替换原有Node的旧值，modCount是不会改变的。 int threshold;// hashMap的size大于该值时 将resize扩容，threshold=capacity*loadFactor（该loadFactor为设置的阈值装载因子，与下面的当前实际装载因子需要注意区分） float loadFactor; // 装载因子 用来衡量 map满的程度，size/capacity,而不是占用的桶的数量/capacity transient Node<K, V>[] table; transient Set<Map.Entry<K, V>> entrySet; /*-------------------static utilities 静态方法----------------*/ static final int hash(Object key) { int h; return key == null ? 0 : (h = key.hashCode()) ^ (h >>> 16);// 为什么不直接使用key的hashCode？。一，防止开发者写的hashcode函数性能不佳，散列不均匀。二，key的hashCode的高位参与运算，数组容量较小时也能使hash值更加均匀。 } // 该算法为求一个不小于给定值的最小2^次幂 static int tableSizeFor(int initialCapacity) { int n = initialCapacity - 1;// 防止initialCapacity本身就是2的x次幂，那么经过以下算法，将返回2的x+1次幂； n |= n >>> 1;// >>>为无符号右移，左边空缺全部补0。经过这一步骤，找出了二进制状态，最高位为1的位，并且最高位和次高位都变为1，结果中前2位变为了1（如果最高位所在位数大于等于2） n |= n >>> 2;// 经过这一步骤，最高2位和次高2位都变为1，结果中前4位变为了1（如果最高位所在位数大于等于4） n |= n >>> 4;// 经过这一步骤，最高4位和次高4位都变为1，结果中前8位变为了1（如果最高位所在位数大于等于8） n |= n >>> 8;// 经过这一步骤，最高8位和次高8位都变为1，结果中前16位变为了1（如果最高位所在位数大于等于16） n |= n >>> 16;// 经过这一步骤，最高16位和次高16位都变为1，结果中前32位变为了1（如果最高位所在位数大于等于32） return (n < 0) ? 1 : (n >= MAX_CAPACITY ? MAX_CAPACITY : n + 1);// 二进制全部变为1后，再进1，即可得到不小于该数的最小2^次幂 } /*-------------------public operations----------------*/ public MyHashMap() { super(); this.loadFactor = LOAD_FACTOR; } public MyHashMap(int initialCapacity) { this(initialCapacity, LOAD_FACTOR); } public MyHashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new RuntimeException("容量不能为负"); if (initialCapacity > MAX_CAPACITY) initialCapacity = MAX_CAPACITY; this.loadFactor = loadFactor; this.threshold = tableSizeFor(initialCapacity);// 很奇怪 为什么是threhold？ this.threshold = tableSizeFor(initialCapacity) *loadFactor； //貌似这样才符合意思。其实构造函数并未对table初始化，初始化是在put函数,到resize函数中进行的，并且在resize中重新计算了threhold值 } public boolean isEmpty() { return size == 0; } public int size() { return size; } public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } /* * put（）思路： * 1.table是否null,是否需要扩容 * 2.根据hash计算数组tab索引i，如果tab[i]==null,直接新建节点插入该槽位，转到步骤6，否则到步骤3 * 3.tab[i]的首个元素的key是否与传入key相同，相同覆盖value，转到步骤6，否则到步骤4 * 4.判断tab[i]是否是treeNode，是，插入树中，转到步骤6，否则到步骤5 * 5.遍历tab[i]时，如果链表的next为空，进行链表的插入操作，插入后，判断长度是否大于8，是则转化为红黑树。如果遍历时发现key值匹配， * 覆盖value 6.插入成功后，判断size是否大于threshold，是否需要扩容 */ private 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;// 注意此处n必须重新赋值，不能只是tab赋值，因为if条件中，有可能只走到前半部分。 } if ((p = tab[(i = hash & (n - 1))]) == null) {// 巧妙之处：计算槽位的时候本来应该为hash%n，但是取模运算效率低下。总槽位n为2的x次幂时，hash%n可以用hash&（n-1）替代，结果一样，效率却可以提升5~8倍。 tab[i] = new Node<K, V>(hash, key, value, null); } else { Node<K, V> e; K k; if (p.hash == hash && ((p.key == key || (key != null && key.equals(p.key))))) {// 该条件就是判断tab[i]的key与传入的key是否相同。用短路与先判断hash值，效率比直接判断key相等更高 e = p;// 为什么不直接p.value=value; } else if (p instanceof TreeNode) { e = putTreeVal(this, tab, hash, key, value);// 此方法先不研究 } else { for (int binCount = 0;; ++binCount) { if ((e = p.next) == null) { p.next = new Node<K, V>(hash, key, value, null);//e还是null if (binCount >= TREEFY_THRESHOLD - 1) { // treefyBin(tab,hash);暂不研究 break; } } if (e.hash == hash && (((k=e.key) == key || (key != null && key.equals(k))))) { break; } p = e; } } //e不为空 说明map中有key相同的节点 if (e != null) { V oldValue=e.value; e.value=value; return oldValue;//如果是覆盖值的操作，直接return，不走到下面，modCount++了，也即只会统计结构改变了的次数 } } ++modCount; if(++size>threshold) resize(); return null; } /*读resize方法之前先明白，由于n（capacity）都是2的x次幂，扩容后，重新计算的节点的索引位置i要么还是i， * 要么是i+oldCap。因为2n-1（32-1:10101）比n-1（16-1:00101）多一个最高位的1，这个1就是 * oldCap的值，那么重新计算索引hash&（2n-1）的时候，只需要看hash & oldCap为0或1即可， * 为0新位置还是i，为1，则新位置为i+oldCap */ private Node<K, V>[] resize() { Node<K,V>[] oldTab=table; int oldCap=(oldTab==null)?0:oldTab.length; int oldThr=threshold; int newCap,newThr=0; if(oldCap>0) {//分支一：扩容时 if (oldCap>=MAX_CAPACITY) { threshold=Integer.MAX_VALUE; return oldTab; } else if((newCap=oldCap<<1)<MAX_CAPACITY&&oldCap>=INIT_CAPACITY) {//新的数组和新的阈值都扩到2倍 newThr = oldThr << 1; } } else if(oldThr>0) {//分支二:oldCap==0,oldThr>0;为调用有参数的构造函数时所执行 newCap=oldThr;//通过tableSizeFor得到的2的n次幂在构造函数中赋值给了threshold，在这里赋值到了capacity，所以下面要重新计算阈值 } else {//分支三:oldCap==0,oldThr==0;为调用无参数的构造函数时所执行 newCap=INIT_CAPACITY; newThr=(int) (newCap*loadFactor); } if(newThr==0) {//只有分支一中的情况二，扩容之后newThr==0 float ft=newCap*loadFactor; newThr=(newCap<MAX_CAPACITY && ft<(float)MAX_CAPACITY)?(int)ft:Integer.MAX_VALUE; } threshold=newThr; //创建新的数组 @SuppressWarnings("unchecked") Node<K,V>[] newTab=(Node<K,V>[])new Node[newCap]; table=newTab; if(oldTab!=null) {//即oldCap>0;为分支一扩容情况,把旧数组中的每个node复制到新数组 for(int j=0;j<oldCap;j++) { Node<K,V> e; if((e=oldTab[j])!=null) {//加这个条件 防止旧数组中有的槽位为空 oldTab[j]=null;//清理旧数组 if(e.next==null) {//没有后继节点 直接赋值到新数组 newTab[e.hash&(newCap-1)]=e; } else if(e instanceof TreeNode) {//红黑树 } else {//链表 Node<K,V> loTail=null,loHead=null;//分别指向新数组中，e.hash&(newCap-1)等于原位置的尾节点和头节点 Node<K,V> hiTail=null,hiHead=null;//分别指向新数组中，e.hash&(newCap-1)等于原位置+oldCap的尾节点和头节点 Node<K,V> next; do{ next=e.next; //原位置 if((e.hash & oldCap)==0) { if(loTail==null) loHead=e; else loTail.next=e; loTail=e;//将尾节点指向新的节点 //原位置+oldCap } 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; } //将重新布置到原位置+oldCap位置的链表的头节点放到数组槽位中 if(hiTail!=null) { hiTail.next=null; newTab[j+oldCap]=hiHead; } } } } } return newTab; } }
8-17补充：
关于为什么X % 2^n = X & (2^n – 1)，在网上找到一个通俗的解释：
假设n为3，则2^3 = 8，表示成2进制就是1000。2^3 = 7 ，即0111。此时X & (2^3 – 1) 就相当于取X的2进制的最后三位数。
从2进制角度来看，X / 8相当于 X >> 3，即把X右移3位，此时得到了X / 8的商，而被移掉的部分(后三位)，则是X % 8，也就是余数。
