在java程序中，Map的实现类HashMap在日常编码中是经常用到的，那么其里面是什么样的呢？
首先从数据结构上来说，HashMap的实现是数组+链表+红黑树（jdk>1.7）。
首先看看里面的属性参数
/** * The default initial capacity - MUST be a power of two. */ static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
看上面的注释：他默认的初始容量-必须是2的幂次方。（初始数组默认长度为16。）
/** * The maximum capacity, used if a higher value is implicitly specified * by either of the constructors with arguments. * MUST be a power of two <= 1<<30. */ static final int MAXIMUM_CAPACITY = 1 << 30;
看上面的注释：最大容量，在隐式指定更高的值时使用，由具有参数的构造函数之一。必须是2的幂<=1<<30。(HashMap的最大容量)
/** * The load factor used when none specified in constructor. */ static final float DEFAULT_LOAD_FACTOR = 0.75f;
看上面的注释：构造函数中未指定时使用的负载因子。（默认的扩容因子为0.75。）
/** * The bin count threshold for using a tree rather than list for a * bin. Bins are converted to trees when adding an element to a * bin with at least this many nodes. The value must be greater * than 2 and should be at least 8 to mesh with assumptions in * tree removal about conversion back to plain bins upon * shrinkage. */ static final int TREEIFY_THRESHOLD = 8;
看上面的注释：使用树而不是列表的容器计数阈值箱子。将元素添加到至少有这么多节点。值必须更大大于2，且应至少为8，以便与树移除关于转换回普通垃圾箱收缩。
链表转红黑树链表长度为8（待定）。
/** * The bin count threshold for untreeifying a (split) bin during a * resize operation. Should be less than TREEIFY_THRESHOLD, and at * most 6 to mesh with shrinkage detection under removal. */ static final int UNTREEIFY_THRESHOLD = 6;
看上面的注释：在调整大小操作。应小于TREEIFY_THRESHOLD，并且大部分6到网目下进行收缩检测。
红黑树转链表数值，小于6时由树转为链表。
/** * The smallest table capacity for which bins may be treeified. * (Otherwise the table is resized if too many nodes in a bin.) * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts * between resizing and treeification thresholds. */ static final int MIN_TREEIFY_CAPACITY = 64;
看上面的注释：可对箱子进行树型化的最小表容量。（否则，如果bin中的节点太多，则调整表的大小。）应至少为4*TREEIFY_THRESHOLD ，以避免冲突，在调整大小和树化阈值之间
链表转红黑树数组最小长度（等会解释）
static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next; Node(int hash, K key, V value, Node<K,V> next) { 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 final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } }
内部类，Node节点。实现了Map接口的内部接口Entry。里面有4个属性
final int hash; //key的hashcode
final K key; //key值
V value; //value值
Node<K,V> next; //链表指向的下一个节点
里面的方法都是实现了Entry接口的方法，里面还有一些Entry自带的比较方法。
/** * The table, initialized on first use, and resized as * necessary. When allocated, length is always a power of two. * (We also tolerate length zero in some operations to allow * bootstrapping mechanics that are currently not needed.) */ transient Node<K,V>[] table;
HashMap的节点数组。数组结构中的数组。(后面都用table代替)
/** * The number of key-value mappings contained in this map. */ transient int size;
HashMap中key-value的数量。
/** * The next size value at which to resize (capacity * load factor). * * @serial */ // (The javadoc description is true upon serialization. // Additionally, if the table array has not been allocated, this // field holds the initial array capacity, or zero signifying // DEFAULT_INITIAL_CAPACITY.) int threshold;
HashMap中size达到这个数会进行table扩容。
/** * The number of times this HashMap has been structurally modified * Structural modifications are those that change the number of mappings in * the HashMap or otherwise modify its internal structure (e.g., * rehash). This field is used to make iterators on Collection-views of * the HashMap fail-fast. (See ConcurrentModificationException). */ transient int modCount;
table被更改次数。
下面来看构造函数：
1.先看默认的构造函数
/** * Constructs an empty <tt>HashMap</tt> with the default initial capacity * (16) and the default load factor (0.75). */ public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted }
把负载因子赋值为默认的0.75，然后就什么都没做了。
/** * Constructs an empty <tt>HashMap</tt> with the specified initial * capacity and the default load factor (0.75). * * @param initialCapacity the initial capacity. * @throws IllegalArgumentException if the initial capacity is negative. */ public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); }
初始化table长度为构造函数中的长度。负载因子用的是默认的负载因子0.75。下面的构造函数为指定扩容因子构造函数，上面的构造函数调用的就是下面的构造函数。我们来看下下面的构造函数干了啥。
/** * Constructs an empty <tt>HashMap</tt> with the specified initial * capacity and load factor. * * @param initialCapacity the initial capacity * @param loadFactor the load factor * @throws IllegalArgumentException if the initial capacity is negative * or the load factor is nonpositive */ public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) //判断传入的table长度是否小于0，如果小于0抛出异常：错误的容量 throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) //判断是否大于HashMap的最大容量，如果大于最大容量，就把initialCapacity为MAXIMUM_CAPACITY(1 << 30) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + //判断负载因子是否小于0，如果小于0抛出异常 loadFactor); this.loadFactor = loadFactor; //负载因子赋值为传入的数值 this.threshold = tableSizeFor(initialCapacity); //赋值为最接近2的n次幂的table长度（看方法注释） }
下面的构造函数为传入一个Map实现类。
/** * Constructs a new <tt>HashMap</tt> with the same mappings as the * specified <tt>Map</tt>. The <tt>HashMap</tt> is created with * default load factor (0.75) and an initial capacity sufficient to * hold the mappings in the specified <tt>Map</tt>. * * @param m the map whose mappings are to be placed in this map * @throws NullPointerException if the specified map is null */ public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; //初始化扩容因子为默认的0.75 putMapEntries(m, false); } /** * Implements Map.putAll and Map constructor * * @param m the map * @param evict false when initially constructing this map, else * true (relayed to method afterNodeInsertion). */ final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) { int s = m.size(); if (s > 0) { //如果Map的size>0，执行以下程序 if (table == null) { // pre-size //如果这个时候table还未初始化 float ft = ((float)s / loadFactor) + 1.0F; int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY); //计算得出一个容量向上取整，如果大于最大容量，就赋值为最大容量，小于就截取 if (t > threshold) threshold = tableSizeFor(t); //如果超过了threshold（此时为0），则取t最近的2的n次幂所得的长度赋值给threshold } else if (s > threshold) resize(); for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) { K key = e.getKey(); V value = e.getValue(); putVal(hash(key), key, value, false, evict); //往table中添加node节点，此时evict为false，每次添加node都是新增节点(后面会讲到更改节点的情况)实际作用不大 } } }
构造方法先到这里，里面的一些问题下面会讲到。接下来我们来看put干了些啥事情。
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); //调用了hashcode方法计算key的hashcode值，在当作参数传入putVal中。 } //再看hash方法 static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); //如果key为null，获取的hashcode为0，如果不是,扰动函数计算key的hashcode，减少hashcode碰撞的几率 } //再看putVal方法 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; //tab：临时存放table；p：临时存放key所计算出的hashcode位运算后所得下标i元素的Node对象；n为table的长度；i为Node在table中下标 if ((tab = table) == null || (n = tab.length) == 0) //判断是不是table是否初始化，如果没有初始化，调用扩容方法，返回一个默认长度为16，扩容因子为0.75的table n = (tab = resize()).length; //如果table未初始化，n赋值为tab的长度，也就是默认的16 if ((p = tab[i = (n - 1) & hash]) == null) //(n - 1) & hash位运算计算出key的hashcode值所放下标应该是多少，赋值给i tab[i] = newNode(hash, key, value, null); //这个时候取tab【i】下标元素赋值一个新的Node； 下面else不走 else { ////////////// 这里是根据key的hashcode取下标元素，这时候元素已经存在table中的情况 ////////// Node<K,V> e; K k; //e：临时Node； k：p（下标为i的Node）的key if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; //这种情况，table中下标为i的元素的key和传入key相同，hashcode计算相同。其余逻辑不走，然后在653行执行更改value操作（覆盖相同key的value，hashMap的特性） else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); //这种情况下是下标为i的元素为红黑树结构了，往红黑树添加，并且平衡树，平衡完成后返回null;所以不更改原有下标元素 else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { //把e赋值为p的下一个Node p.next = newNode(hash, key, value, null); //（这个情况是p Node这个时候还未链表化）如果p的下一个Node为空，创建找寻到原有Node p 的next Node 由此得出重要结论（链表转树，TREEIFY_THRESHOLD是8，但是链表长度不一定是8，而且肯定比8要大，因为下一个链表节点已经创建，下面链表转树方法也将说明，链表转树，链表长度不一定为8） if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); //尝试链表转树，然后跳出循环 break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) //Node p存在next Node（这个情况是p Node这个时候已经链表化）； Node e的hash和key都为传入的key的hashcode一致，并且e的key和传入的key一致，直接跳出循环 break; p = e; //（这个时候p已经链表化）上面两种情况都不满足的话，把 p Node指向下一个Node e，继续循环，然后就会走第二个if情况，跳出循环，链表上层和下次互换位置 } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; //table被修改次数+1 if (++size > threshold) //如果达到了扩容量，进行扩容 resize(); afterNodeInsertion(evict); return null; } 下面附treeifyBin方法 final void treeifyBin(Node<K,V>[] tab, int hash) { //链表转树结构 int n, index; Node<K,V> e; if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) //如果长度达不到MIN_TREEIFY_CAPACITY（64），不会进行转树，会先进性扩容 resize(); else if ((e = tab[index = (n - 1) & hash]) != null) { //key的hashcode经过位运行得到得table下标i不为空得话，进行链表转为树结构 TreeNode<K,V> hd = null, tl = null; do { TreeNode<K,V> p = replacementTreeNode(e, null); 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); } }
问题1：为什么传入初始table长度，HashMap会直接转成最靠近2的n次幂数字呢？
原因看上面方法putVal中的根据key的hashcode获取具体下标元素时：
tab[i = (n - 1) & hash] 这个时候位运算的结果相当于hashcode%table.length ，如果不是2的n次幂，那么这个将不成立，位运算在hashMap的size相当大的时候，
位运算得出下标要比取模得出下标效率要高出太多。所以，HashMap的table长度必须为2的n次幂，如果不是，会被强制转为2的n次幂。
问题2：扩容因子为什么是0.75？有必要去更改扩容因子吗？
这个时候我们可以回过头看HashMap的注释：
* <p>As a general rule, the default load factor (.75) offers a good * tradeoff between time and space costs. Higher values decrease the * space overhead but increase the lookup cost (reflected in most of * the operations of the <tt>HashMap</tt> class, including * <tt>get</tt> and <tt>put</tt>). The expected number of entries in * the map and its load factor should be taken into account when * setting its initial capacity, so as to minimize the number of * rehash operations. If the initial capacity is greater than the * maximum number of entries divided by the load factor, no rehash * operations will ever occur.
从上面可以看出，HashMap给出的扩容因子建议就是0.75，那么0.75是怎么来的呢？为什么是0.75，不是其他的呢？
首先，我们从时间复杂度上面来考虑，我可以把扩容因子设置为0.5，这样hash碰撞的概率就小了很多，达到长度tabe就扩容找寻元素效率大大提升（缺点：空间利用率变低，每次扩容都还有一半空间未使用，空间换时间）。
然后从空间复杂度上面来看，如果我设置为1的话，当table元素满了我才去扩容，这样空间利用率变高了。（缺点：hash碰撞概率提升，找寻元素效率降低，时间换空间）。
从空间复杂度和时间复杂度上面看，取0.75是个比较折中的数字。但是，并不是这么回事，0.5和1之间，根据牛顿二项式推导出的结论为0.698...，HashMap开发人员取折中选为0.75。
问题3：链表在什么时候会转为红黑树？
答案在上面源码中贴出了，链表长度在达到8的时候会去尝试由链表转为树结构，但是是先创建了next Node，所以，链表此时已经不是8的长度了，而且，如果数组长度达不到MIN_TREEIFY_CAPACITY(64)，尝试转树结构只会给数组扩容，并不会去实际转树结构，参照方法treeifyBin，和putVal中来看：所以链表在转树的情况下，有两个必要条件（链表长度>=8&&table.length>=64）
问题4：为什么链表长度达到8的时候会去尝试转为红黑树呢？
我们可以看看HashMap的注释：
* Because TreeNodes are about twice the size of regular nodes, we * use them only when bins contain enough nodes to warrant use * (see TREEIFY_THRESHOLD). And when they become too small (due to * removal or resizing) they are converted back to plain bins. In * usages with well-distributed user hashCodes, tree bins are * rarely used. Ideally, under random hashCodes, the frequency of * nodes in bins follows a Poisson distribution * (http://en.wikipedia.org/wiki/Poisson_distribution) with a * parameter of about 0.5 on average for the default resizing * threshold of 0.75, although with a large variance because of * resizing granularity. Ignoring variance, the expected * occurrences of list size k are (exp(-0.5) * pow(0.5, k) / * factorial(k)). The first values are: * * 0: 0.60653066 * 1: 0.30326533 * 2: 0.07581633 * 3: 0.01263606 * 4: 0.00157952 * 5: 0.00015795 * 6: 0.00001316 * 7: 0.00000094 * 8: 0.00000006 * more: less than 1 in ten million
上图的0,1,2,3,4,5,6,7,8为链表长度概率（根据泊松分布概率计算得出），从上面可以看出，当链表长度为8的时候，已经是亿分之6的概率了，已经无限趋近于0，可以忽略不计；
(exp(-0.5) * pow(0.5, k) /factorial(k) 计算得出为8
我们下面再看数组扩容（resize）做了哪些事情
final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; //获取原table的长度 int oldThr = threshold; //把原有扩容容量赋值给oldThr int newCap, newThr = 0; //扩容后数组的长度和下一次扩容的扩容量 if (oldCap > 0) { //如果table长度不为0 if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; //数组长度>=hashMap的最大容量，下次扩容量更改为2147483647（这个数要比HashMap的最大容量还要大），往后，数组都不会进行扩容了 return oldTab; } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) //这个地方如果原table长度小于HashMap的最大容量并且大于默认长度(16)，新的数组长度(newCap)变为原有长度的两倍 newThr = oldThr << 1; // double threshold //新的扩容量也随之*2 } else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; //扩容后数组长度赋值为原扩容容量 //能到这里，说明调用的是带有table长度的构造方法初始化（具体是哪个构造函数。---有两个可选，往上翻） else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; //到这个else中说明这个时候table还未进行初始化，调用这个扩容方法来返回一个默认长度的table newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } if (newThr == 0) { //如果新的扩容量为0，上面判断走的是第二种情况 float ft = (float)newCap * loadFactor; //table长度*扩容因子，计算新的扩容量 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]; //新创建一个长度为Node数组（newCap有三种情况：1-默认的16；2-调用了带有数组长度的构造函数，这个时候newCap会转为数组长度最接近的2的n次幂；3-原有扩容量的两倍） table = newTab; //将table指向新的Node数组 长度已经搞定了，下面是元素的移动 if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { //循环原有的table Node<K,V> e; //新的Node （原table的【j】Node） if ((e = oldTab[j]) != null) { //把e指向原table的【j】Node，如果不为空，执行下面一系列操作 oldTab[j] = null; //把原table的【j】指向为null if (e.next == null) //判断原table的【j】Node是否为链表 newTab[e.hash & (newCap - 1)] = e; //如果不是链表，把新的table【】的Node指向e（原有table的【j】Node） 直接移动到原下标【j】 + oldCap（原table长度）位置（不需要重新计算hashcode，重新计算也是这个值，高，实在是高。位运算，永远滴神） else if (e instanceof TreeNode) //原Node已经树化了 ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); //将原有树平衡好移到新的table中 else { // preserve order //这种情况，原Node（oldTab【j】）已经链表化了 Node<K,V> loHead = null, loTail = null; //loHead（低位头Node） loTail（低位尾Node） Node<K,V> hiHead = null, hiTail = null; //hiHead（高位头Node） hiTail（高位尾Node） Node<K,V> next; do { //这是一个拆链重组的过程，直到链表的末尾，循环结束 （因为不同的table长度，计算所得下标会不同，所以需要判断链表内的所有Node是否需要重新移动位置） next = e.next; if ((e.hash & oldCap) == 0) { //判断e是否需要在新的table中更换位置（如果为0，不需要变更位置） if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { //更改e在新table中的位置 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; //需要更改位置的Node链，在下标【j】+原table长度的位置 } } } } } return newTab; }
上面注释很清晰解释了数组在扩容的时候，都经历了什么过程。中间Node如果为链表的话，进行拆链重组的过程，如果计算Node.hash & oldCap为0，则不需要移位如果不为0，则需要重新计算在新数组中的下标（原下标+原table长度）e.hash & (newCap - 1)
问题5：table在没有初始化的时候会去扩容吗？
那肯定会去扩容的，在你put的时候，判断table是否为null；如果为null，则去调用resize方法返回一个默认长度16的table（为啥看上面代码解释）
问题6：table在什么时候会进行扩容，是怎么个扩容方式
table里面元素个数达到threshold（table.length*扩容因子）的时候，会去进行扩容 （看putVal方法最后第三行），扩容方式如果小于HashMap最大容量，两倍长度扩容（上面注释有）；
但是，如果达到了最大容量，将不会在进行扩容，并且会把下次扩容量提升到Integer.MAX_VALUE（2147483647），所以，table在达到最大容量的时候不会进行扩容，因为下次扩容量已经要
比最大容量1 << 30（1073741824）还要大，所以达不到下次库容量，HashMap不在会进行扩容。