HashMap原码简析
<1> put方法简析，逻辑步骤如下
- 进入put()方法，对key进行hash，获取key的hashcode码
- 进入putVal() 判断当前table是否为null或者size==0,如果是则为该HashMap进行创建默认的table表。
- 判断根据hashCode获取在table里面的index位置
- 判断获取到的index对应的位置有没有元素存在，如果没有元素存在，则直接创建Node节点，将新创建的Node放到改index下面.
- 如果存在元素，则判断新添加的key和该节点的key是否相当，如果相等，则替换用新的value替换旧的value, 返回旧的value
- 如果key不相当，则判断当前节点是不是TreeNode的实例，即该index下面是不是红黑树结构，如果是，遍历树结构进行新增或者添加
- 如果不是树结构，则表明当前位置是一个链表，则遍历链表，如果找到对应的相等的key, 则返回该节点，用新value替换原值； 如果没找到，则用传入的key-value创建Node加入链表尾部。
- 新添加链表尾部后，判断当前链表长度是否达到了转换为红黑树的临界点，如果达到了，则将链表转换为红黑树。
- 如果确认添加了新元素，则判断当前Map的size是否达到了数组长度的 3/4， 如果达到了则调用resize()方法进行扩容；
- put方法，如果put的key在Map中存在，则覆盖原来值，返回旧值；如果不存在，则新添加元素，返回null.
// hashMap1.8 put方法分析 public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } /** * Implements Map.put and related methods * * @param hash hash for key * @param key the key * @param value the value to put * @param onlyIfAbsent if true, don't change existing value * @param evict if false, the table is in creation mode. * @return previous value, or null if none */ //具体的put实现方法 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { //定义局部变量 HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i; //判断原table是否为空，如果为空，则调用resize方法进行初始化 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //根据写入key的hash值确定key在table的下标，赋值给p并判断p等不等于null if ((p = tab[i = (n - 1) & hash]) == null) //如果目标下标为空，则直接new一个Node对象放在该下标下 tab[i] = newNode(hash, key, value, null); else { //如果目标下标对应的值不为空 HashMap.Node<K,V> e; K k; //判断当前下标下存的Node的对象，的key和新插入put进来的是不是同一个 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) //如果是，则将p赋值个e e = p; //如果当前下标下对应的key和新写入的不一样，则判断当前Node是不是TreeNode类型 else if (p instanceof HashMap.TreeNode) //如果是，则将元素添加到红黑树结构中 e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { //如果当前节点不是TreeNode类型，说明当前index下是一个链表，将新值添加到链表里 //添加方法，遍历链表，如果存在key, 则将对应节点赋值个e,结束循环，如果不存在，则将新添加的key-value添加到链表结尾 //binCount 用来记录当前index下对应的链表长度， for (int binCount = 0; ; ++binCount) { //如果当前节点的下一个节点为null,则用新put进来的值创建Node,放在链表的结尾 if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); //如果当前链表长度大于等于 TREEIFY_THRESHOLD - 1， 则将链表转换为红黑树结构，因为次数新添加的Node还没有统计到binCount中 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st //将链表转换为红黑树 treeifyBin(tab, hash); break; } //如果新put进来的key等于p的key(这里是指同一个对象，或者对象equals为true),结束链表遍历 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; //为下一次循环做准备 p = e; } } //根据以上的逻辑处理，如果e不为空，则表示hashMap里面已经存在形同key的接口，则近新值赋值给对应的Node的value，返回之前的value if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) //新值复制给value，覆盖老值 e.value = value; afterNodeAccess(e); //返回老的值 return oldValue; } } //用于记录HashMap的修改次数, 在迭代中使用 ++modCount; //添加完元素，判断HashMap的元素个数，是否超过了扩容界限，如果超过了，则进行扩容 if (++size > threshold) //调用resize()方法进行扩容 resize(); //用在子类扩展，put元素成功后做一些自定义逻辑 afterNodeInsertion(evict); //如果hashMap里面不存在对应的key，添加成功返回null return null; }
<2> get()方法简析，查找步骤如下
- 判断容器是否为空，若为空，直接返回null
- 判断hash确认的index位置是否为空，为空，直接返回null
- 判断index位置的Node的key和参数传入的相不相等，若相等，直接返回first节点；
- 若不相等，判断first的next节点，是否为空，如果为空，直接返回null；
- 若不为空，（1）判断首节点是否为TreeNode实例，如果是，则该位置是一个红黑树，遍历红黑树，根据key值查找对应的Node节点；（2）如果是链表，则遍历链表根据key找对应的Node节点。
- 最后如果找到则返回对应的Node, 找不到，则直接返回null。
/** * JDK1.8 get 方法 * @param key * @return */ public V get(Object key) { HashMap.Node<K,V> e; //获取节点，如果取到则返回其值，取不到返回null 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 HashMap.Node<K,V> getNode(int hash, Object key) { //设置局部表里 HashMap.Node<K,V>[] tab; HashMap.Node<K,V> first, e; int n; K k; //判断当前Map是否为空 //判断hash值确定的数组位置是否为null if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { //如果key的hash相当，并且key相等，则反复index位置的头节点 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; //如果头节点的next不为空，向下查询 if ((e = first.next) != null) { //树结构，遍历查找 if (first instanceof HashMap.TreeNode) //查到返回 return ((HashMap.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); } } //没查到返回null return null; }
<3> resize()方法解析，步骤如下
- 判断当前容器是否为空，为空则表示新创建容器，直接使用默认值创建table;
- 如果不为空，则是扩容，判断是否达到了容量限制最大值，如果达到了，则不再进行扩容，并将扩容负载数设置为 Integer.MAX_VALUE;
- 确定了容器容量和扩容负载数，则创建Table；
- 如果原容器为空，说明是初次使用创建容器，则直接返回；如果不为空，说明是容器扩容，后面进行copy元素。
- 元素copy, 根据当前的hash碰撞算法，每一个元素在新的容器里的index位置，有两个，一个还是之前的index位置，另一个在原index+oldCap的位置。
- 返回table。
/** * HashMap Jdk1.8 resize方法 * @return */ final HashMap.Node<K,V>[] resize() { HashMap.Node<K,V>[] oldTab = table; //获取原Map的数组长度（容量） int oldCap = (oldTab == null) ? 0 : oldTab.length; //设置容器扩容负载数 int oldThr = threshold; int newCap, newThr = 0; //判断原Map的数组长度是否大于0 if (oldCap > 0) { //判断原Map的数组长度是否大于最大数字容量，MAXIMUM_CAPACITY 默认值：1 << 30 if (oldCap >= MAXIMUM_CAPACITY) { //如果是，则以达到最大允许容量，则设置当前容器扩容负责数为 Integer.MAX_VALUE threshold = Integer.MAX_VALUE; //返回原Map return oldTab; } //原容器容量 * 2 小于最大容量， 并且原容器容量大于初始容量，默认：16 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) //扩容负载数 * 2 newThr = oldThr << 1; // double threshold } else if (oldThr > 0) // initial capacity was placed in threshold //如果原容器数组长度（容量）小于零，但是扩容负载数大于零，则将原容器扩容负载数设置给新容器的容量 //后面会向上取值，得到2^n， 比如12->16 newCap = oldThr; else { // zero initial threshold signifies using defaults //如果原容器未初始化：则新容器容量设置默认值，扩容负载数设置默认： 负载因子 * 容器默认容量 newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } if (newThr == 0) { //如果扩容负载数为0，根据下面算法进行重置 float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } threshold = newThr; //根据上面计算得到的容器容量,创建容器 @SuppressWarnings({"rawtypes","unchecked"}) HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap]; table = newTab; //如果原Map不为空，说明是扩容，扩容后需要对移动元素，下面的逻辑就是copy原Map的元素到新Map if (oldTab != null) { //遍历原Map里面table的每一个索引位 for (int j = 0; j < oldCap; ++j) { HashMap.Node<K,V> e; //对应索引的下的Node值不为空（若为空则继续遍历下一个index位置） if ((e = oldTab[j]) != null) { //将原table的对应的index位置为null，为GC做准备 oldTab[j] = null; //如果原table的index位只有一个Node，则直接用其Hash值确定在新Map的位置，填入对应的位置 if (e.next == null) newTab[e.hash & (newCap - 1)] = e; else if (e instanceof HashMap.TreeNode) //如果当前index的位置的Node有next, 则判断节点位置是否TreeNode,如果是则表明此处是一个红黑树，进行红黑树操作 ((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // preserve order //否则是一个链表结构 HashMap.Node<K,V> loHead = null, loTail = null; HashMap.Node<K,V> hiHead = null, hiTail = null; HashMap.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 { //这里表示扩容后，元素位置的index为在：原 index + oldCap处（具体原因可自行查询） if (hiTail == null) hiHead = e; else //每次添加元素，在链表的尾部 hiTail.next = e; hiTail = e; } } while ((e = next) != null); //上面循环中，构建了两个链表，他们的index位置分别在： j 和 j+oldCap 处 //如果两个链表不为空，这里则将链表分别添加到对应的位置 if (loTail != null) {//这里表示链表至少有一个节点 loTail.next = null; newTab[j] = loHead; } if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } //返回容器 return newTab; }
（笔记整理，后续完善）