简介：
在jdk1.8中，hashmap有了较大的优化，底层实现由之前的“数组+链表”改为了“数组+链表+红黑树”。jdk1.8的hashmap的数据结构如图所示，当链表节点较少时仍然以链表形式存在，当链表节点较多时（大于8）会转化为红黑树。
重要知识点：
1、文章中头节点指的是table表上索引位置的节点，也就是链表的头结点
2、根节点（root）指的是红黑树最上面的节点，也就是没有父节点的节点
3、红黑树的根节点不一定是索引位置的头结点（链表的头结点），hashmap通过moveRootToFront方法来维持红黑树的根节点就是索引位置的头结点，但是在removeTreeNode方法中，当movable为false时，不会调用moveRootToFront方法，此时红黑树的根节点不一定是索引位置的头结点，该情形发生在hashIterator的remove方法中
4、转为红黑树之后，链表的结构还存在，通过next属性维持，红黑树节点在进行操作时都会维护链表的结构，并不是转化为红黑树节点，链表结构就不存在了
5、在红黑树上，叶子节点也可能有next节点，因为红黑树的结构与链表的结构是互不影响的，不会因为是叶子节点就说该节点已经没有next节点
6、源码中的一些变量的定义为：如果定义了一个节点p，则pl（p left）为p的左节点，pr（p right）为p的右节点，pp（p parent）为p的父节点，ph（p hash）为p的hash值，pk（p key）为p的key值，kc（key class）为key的类等等。
7、链表中移除一个节点只需要如图的操作
8、红黑树在维护链表结构时，移除一个节点只需要如图所示操作（红黑树中增加了一个prev属性），其他操作同理。注：此处只是红黑树维护链表结构的操作，红黑树还需要单独进行红黑树的移除或者其他操作
9、源码中进行红黑树的查找时，会反复使用两条规则：1）如果目标节点的hash值小与p节点的hash值，则向p节点的左边遍历；否则向p节点的右边遍历。2）如果目标节点的key值小与p节点的key值，则向p节点的左边遍历；否则向p节点的右边遍历。这两条规则是利用了红黑树的特性（左节点<根节点<右节点）
10、源码中进行红黑树的查找时，会用dir（direction）来表示向左还是向右查找，dir存储的值是目标节点的hash/key与p节点的hash/key的比较结果
基本属性：
// 默认容量16 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 最大容量 static final int MAXIMUM_CAPACITY = 1 << 30; // 默认负载因子0.75 static final float DEFAULT_LOAD_FACTOR = 0.75f; // 链表节点转换红黑树节点的阈值, 9个节点转 static final int TREEIFY_THRESHOLD = 8; // 红黑树节点转换链表节点的阈值, 6个节点转 static final int UNTREEIFY_THRESHOLD = 6; // 转红黑树时, table的最小长度 static final int MIN_TREEIFY_CAPACITY = 64; // 链表节点, 继承自Entry static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> 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; // ... }
定位哈希桶数组索引位置
由于HashMap的数据结构为“数组+链表+红黑树”的组合，所以我们希望这个HashMap里面的元素位置尽量分布地更加均匀，尽量使得每个位置上的元素数量只有一个，那么当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，不用遍历链表/红黑树，大大优化了查询的效率。HashMap定位数组索引的位置，直接决定了hash方法的离散性能。源码为：
// 代码1 static final int hash(Object key) { // 计算key的hash值 int h; // 1.先拿到key的hashCode值; 2.将hashCode的高16位参与运算 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } // 代码2 int n = tab.length; // 将(tab.length - 1) 与 hash值进行&运算 int index = (n - 1) & hash;
1、拿到key的hashCode值
2、将hashCode的高位参与运算，重新计算hash值
3、将计算出来的hash值于（table.length-1)进行&运算
解读：对于任意给定的对象，只要他的hashCode()返回值相同，那么计算得到的hash值总是相同的。把hash值对table长度取模运算，这样一来，元素的分布相对来说是比较均匀的。
但是模运算的消耗比较大，计算机中的位运算比较快，因此使用代码2的位与运算来代替模运算。他通过(table.length-1)&h来获得该对象的索引位置。
在JDK1.8的实现中，还优化了高位运算的算法，将hashCode的高16位与hashCode进行异或运算，主要是为了在table的长度较小的时候，让高位也参与运算，并且不会有太大的开销。
例子：
当table的长度为16时，table.length-1=15，在二进制中，此时低四位全部为1，高28位全部为0，当0进行&运算时结果必然为0，因此此时hashCode与“table.length-1”的&运算只取决于hashCode的低四位，在这种情况下，hashCode的高28位就没起到任何作用，并且由于hash结果只取决于hashCode的低4位，hash冲突的概率也会增加。因此，在JDK1.8中，将高位也参与计算，目的是为了降低hash冲突的概率。
get方法：
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; // 1.对table进行校验：table不为空 && table长度大于0 && // table索引位置(使用table.length - 1和hash值进行位与运算)的节点不为空 if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { // 2.检查first节点的hash值和key是否和入参的一样，如果一样则first即为目标节点，直接返回first节点 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; // 3.如果first不是目标节点，并且first的next节点不为空则继续遍历 if ((e = first.next) != null) { if (first instanceof TreeNode) // 4.如果是红黑树节点，则调用红黑树的查找目标节点方法getTreeNode return ((TreeNode<K,V>)first).getTreeNode(hash, key); do { // 5.执行链表节点的查找，向下遍历链表, 直至找到节点的key和入参的key相等时,返回该节点 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } // 6.找不到符合的返回空 return null; }
4.如果是红黑树节点，则调用红黑树的查找目标节点方法 getTreeNode。
final TreeNode<K,V> getTreeNode(int h, Object k) { // 1.首先找到红黑树的根节点；2.使用根节点调用find方法 return ((parent != null) ? root() : this).find(h, k, null); }
2.使用根节点调用 find 方法。
/** * 从调用此方法的节点开始查找, 通过hash值和key找到对应的节点 * 此方法是红黑树节点的查找, 红黑树是特殊的自平衡二叉查找树 * 平衡二叉查找树的特点：左节点<根节点<右节点 */ final TreeNode<K,V> find(int h, Object k, Class<?> kc) { // 1.将p节点赋值为调用此方法的节点，即为红黑树根节点 TreeNode<K,V> p = this; // 2.从p节点开始向下遍历 do { int ph, dir; K pk; TreeNode<K,V> pl = p.left, pr = p.right, q; // 3.如果传入的hash值小于p节点的hash值，则往p节点的左边遍历 if ((ph = p.hash) > h) p = pl; else if (ph < h) // 4.如果传入的hash值大于p节点的hash值，则往p节点的右边遍历 p = pr; // 5.如果传入的hash值和key值等于p节点的hash值和key值,则p节点为目标节点,返回p节点 else if ((pk = p.key) == k || (k != null && k.equals(pk))) return p; else if (pl == null) // 6.p节点的左节点为空则将向右遍历 p = pr; else if (pr == null) // 7.p节点的右节点为空则向左遍历 p = pl; // 8.将p节点与k进行比较 else if ((kc != null || (kc = comparableClassFor(k)) != null) && // 8.1 kc不为空代表k实现了Comparable (dir = compareComparables(kc, k, pk)) != 0)// 8.2 k<pk则dir<0, k>pk则dir>0 // 8.3 k<pk则向左遍历(p赋值为p的左节点), 否则向右遍历 p = (dir < 0) ? pl : pr; // 9.代码走到此处, 代表key所属类没有实现Comparable, 直接指定向p的右边遍历 else if ((q = pr.find(h, k, kc)) != null) return q; // 10.代码走到此处代表“pr.find(h, k, kc)”为空, 因此直接向左遍历 else p = pl; } while (p != null); return null; }
明天再写