Java中的HashMap源码解析

   //序列化版本号，在序列化和反序列化的时候使用
   private static final long serialVersionUID = 362498820763181265L;
  //集合初始容量为16，   
  static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
   //最大容量 table数组存放元素的最大数量  
   static final int MAXIMUM_CAPACITY = 1 << 30;
    //负载因子默认为0.75   负载因子= 表中的元素个数/散列表的长度，达到0.75扩容  
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //链表转成树的阈值，链表中的元素个数大于8，变为红黑树和MIN_TREEIFY_CAPACITY一起决定的
    static final int TREEIFY_THRESHOLD = 8;
     //树转换成链表的阈值    树中的元素小于6，转换为链表
     static final int UNTREEIFY_THRESHOLD = 6;
    //最小转成树的容量，当数组长度达到64转换为红黑树----和TREEIFY_THRESHOLD一起决定的
    static final int MIN_TREEIFY_CAPACITY = 64;

   //存放元素的数组 
    transient Node<K,V>[] table;
    //存放Entry类型的元素集合  
    transient Set<Map.Entry<K,V>> entrySet;
   //哈希表中元素的个数
    transient int size;
    //每次扩容和更改map结构的计数器
    transient int modCount;
   //扩容的阈值，当实际大小为(16 * 0.75 = 12) 阈值时开始扩容 
    int threshold;
   //哈希表自己的负载因子
    final float loadFactor;

//指定容量大小的构造函数
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/*
	 指定“容量大小”和“加载因子”的构造函数
	 initialCapacity: 指定的容量
	 loadFactor:指定的加载因子
*/
public HashMap(int initialCapacity, float loadFactor) {
    //判断初始化容量initialCapacity是否小于0
    if (initialCapacity < 0)
        //如果小于0，则抛出非法的参数异常IllegalArgumentException
        throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
    //判断初始化容量initialCapacity是否大于集合的最大容量MAXIMUM_CAPACITY-》2的30次幂
    if (initialCapacity > MAXIMUM_CAPACITY)
        //如果超过MAXIMUM_CAPACITY，会将MAXIMUM_CAPACITY赋值给initialCapacity
        initialCapacity = MAXIMUM_CAPACITY;
    //判断负载因子loadFactor是否小于等于0或者是否是一个非数值
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        //如果满足上述其中之一，则抛出非法的参数异常IllegalArgumentException
        throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
    //将指定的加载因子赋值给HashMap成员变量的负载因子loadFactor
    this.loadFactor = loadFactor;
    /*
    		tableSizeFor(initialCapacity) 判断指定的初始化容量是否是2的n次幂，如果不是那么会变为比指定初始化容量大的最小的2的n次幂。
    		但是注意，在tableSizeFor方法体内部将计算后的数据返回给调用这里了，并且直接赋值给threshold边界值了。有些人会觉得这里是一个bug,应该这样书写：
    		this.threshold = tableSizeFor(initialCapacity) *this.loadFactor;
    		这样才符合threshold的意思（当HashMap的size到达threshold这个阈值时会扩容）。
			但是，请注意，在jdk8以后的构造方法中，并没有对table这个成员变量进行初始化，table的初始化被推迟到了put方法中，在put方法中会对threshold重新计算
    	*/
    this.threshold = tableSizeFor(initialCapacity);
}
//无参构造
 public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

//返回比指定初始容量大的最小的2的n次方
  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;
    }

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) {
    //transient Node<K,V>[] table; 表示存储Map集合中元素的数组。
    Node<K,V>[] tab;
    Node<K,V> p; 
    //n代表数组的长度
    int n, i;
    // ① 将table赋值给tab,并判断是否为null，第一次赋值时肯定为null
    // ② 将tab.length赋值给n，并判断是否为0
    if ((tab = table) == null || (n = tab.length) == 0)
        //③ 由于数组为tab==null，对数组进行初始化，并将初始化后的数组长度赋值给n
        //④ 执行n = (tab = resize()).length，数组tab每个空间都是null
        n = (tab = resize()).length;
    // ① i = (n - 1) & hash 表示计算数组的索引赋值给i，即确定元素存放在哪个桶中
    // ② p = tab[i = (n - 1) & hash] 将计算出的数组索引对应的数据赋值给节点p
    // ③ 判断p是否为null，即当前桶没有哈希冲突，则直接把键值对插入空间位置
    if ((p = tab[i = (n - 1) & hash]) == null)
        // ④ 根据键值对创建新的节点放入该位置的桶中
        // p表示tab[i]，即 newNode(hash, key, value, null)方法返回的Node对象。
        tab[i] = newNode(hash, key, value, null);
    else {
        // ① 执行else说明p=tab[i]不等于null，表示这个位置已经有值了，
        Node<K,V> e; K k;
        // ② p.hash == hash：比较桶中元素的hash值和新添加元素key的hash值是否相等
        // ③ (k = p.key) == key：比较两个key的地址值是否相等
        // ④ (key != null && key.equals(k))：能够执行到这里说明两个key的地址值不相等，
 //那么先判断后添加的key是否等于null，如果不等于null再调用equals方法判断两个key的内容是否相等
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            	// 两个元素哈希值相等，并且key的值也相等，将旧的元素整体对象赋值给e，用e来记录
                e = p;
        // hash值不相等或者key不相等；判断p是否为红黑树结点
        else if (p instanceof TreeNode)
            // 放入树中
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        // hash值不相等或者key不相等，说明是链表节点
        else {
            // 如果hash(key)不相同，说明是计算的桶下标相同，key也不相同，说明直接插在链表最后
            for (int binCount = 0; ; ++binCount) {
                // ① e = p.next 获取p的下一个元素赋值给e
                // ② 判断p.next是否等于null，等于null，说明p没有下一个元素
                // ③ 到达了链表的尾部，还没有找到重复的key,说明HashMap没有包含该键，将该键值对插入链表中
                if ((e = p.next) == null) {
                    //④ 创建一个新的节点插入到尾部
                    p.next = newNode(hash, key, value, null);
                    //① 节点添加完成之后判断此时节点个数是否大于临界值8，如果大于则将链表转换为红黑树
                    //② binCount从0开始计数，TREEIFY_THRESHOLD - 1=7
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        //转换为红黑树
                        treeifyBin(tab, hash);
                    break;
                }
                // ① e = p.next 不是null，不是最后一个元素。
                // ②继续判断链表中结点的key值与插入的元素的key值是否相等
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等，跳出循环
                    //要添加的元素和链表中的存在的元素的key相等了，则跳出for循环。
                    //不用再继续比较了，直接执行下面的if语句去替换去 if (e != null) 
                    break;
                //说明新添加的元素和当前节点不相等，继续查找下一个节点。
                // 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
                p = e;
            }
        }
        /*
        	表示在桶中找到key值、hash值与插入元素相等的结点
        	也就是说通过上面的操作找到了重复的键，所以这里就是把该键的值变为新的值，并返回旧值
        	这里完成了put方法的修改功能
        */
        if (e != null) { 
            // 记录e的value
            V oldValue = e.value;
            // onlyIfAbsent为false或者旧值为null
            if (!onlyIfAbsent || oldValue == null)
                //用新值替换旧值:e.value 表示旧值  value表示新值 
                e.value = value;
            // 访问后回调
            afterNodeAccess(e);
            // 返回旧值
            return oldValue;
        }
    }
    //修改记录次数
    ++modCount;
    // 判断实际大小是否大于threshold阈值，如果超过则扩容
    if (++size > threshold)
        resize();
    // 插入后回调
    afterNodeInsertion(evict);
    return null;
} 

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
    	// n表示数组初始化的长度是16 
    	// 数组的长度必须为2的n次方，这样能够让hash(key)更加均匀的分布在桶下标中，减少hash冲突
    	// 使用 & 运算是为了提高效率
        if ((p = tab[i = (n - 1) & hash]) == null)
}

final Node<K,V>[] resize() {
    //得到当前数组
    Node<K,V>[] oldTab = table;
    //如果当前数组等于null长度返回0，否则返回当前数组的长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //旧阈值点 默认是12(16*0.75)
    int oldThr = threshold;
    int newCap, newThr = 0;
   //第一次的数组容量都是0肯定
    // ① 数组容量>0
    if (oldCap > 0) {
        // ① 超过最大值就不再扩充了，就只好随你碰撞去吧
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // ② 没超过最大值，数组容量就扩充为原来的2倍，newCap = 16*2=32
        else if((newCap = oldCap << 1)< MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
            //阈值扩大一倍， 默认原来是12 乘以2之后变为24
            newThr = oldThr << 1; 
    }
    //② 旧阈值点大于0 直接赋值
    else if (oldThr > 0) 
        newCap = oldThr;
    //③ 直接使用默认值
    else {
        newCap = DEFAULT_INITIAL_CAPACITY;//16
        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 = 24
    threshold = newThr;
    // ③ 创建新的哈希表，数组大小为newCap=32
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    // ④ 判断旧数组不等于空，遍历旧的哈希表 ,重新计算桶里元素的新位置,把每个bucket都移动到新的buckets中
    if (oldTab != null) {
        // 把每个bucket都移动到新的buckets中
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            //取出桶中的元素赋值给e
            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;
                     	//① e这个节点在resize之后不需要移动位置 
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        //② 否则e这个节点要插入的位置为：原索引+oldCap
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 原索引放到bucket里
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 原索引+oldCap放到bucket里
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    //① 如果数组为空，或者数组的长度小于64，就先扩容，而不是将节点转为红黑树
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    //②  执行到这里说明哈希表中的数组长度大于阈值64，开始进行树形化
    // 将数组中的元素取出赋值给e,e是哈希表中指定位置桶里的链表节点，从第一个开始
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        ///hd：红黑树的头结点   tl :红黑树的尾结点
        TreeNode<K,V> hd = null, tl = null;
        do {
            //新创建一个树的节点，内容和当前链表节点e一致
            TreeNode<K,V> p = replacementTreeNode(e, null);
            //将新创键的p节点赋值给红黑树的头结点
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        //让桶中的第一个元素即数组中的元素指向新建的红黑树的节点，以后这个桶里的元素就是红黑树,而不是链表数据结构了
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {
        //判断数组中的第一个节点的hash、key的地址、key的内容是否和要查找的key相同，如果相同返回即可
        if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        //如果数组中节点还指向了下一个节点
        if ((e = first.next) != null) {
            //如果是红黑树，调用红黑树的getTreeNode()方法
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            //如果是链表，遍历链表，查找与key相同的键对应的节点，找到只有返回当前节点
            do {
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}