JDK1.8 Hashmap源码解析

一、基础知识

1、注释

• 允许空值和空键；key为null依旧可以hash，所以可以存入。取值时，根据containsKey(key)来判断取到的null是没有值还是值为null
• 无序：不保证map中的顺序，不保证顺序一直不变；
• 两个重要元素：初始大小和负载因子（初始大小默认16，负载因子默认为0.75）；
  当已存储的数量 > 容量 * 负载因子，hashmap自动增大为原来大小的两倍，重新散列(rehash，消耗大)。
  负载因子越高，空间消耗越小，hash冲突更多，所以查询map中元素消耗时间越多。负载因子是0.75的时候，空间利用率比较高，而且避免了相当多的Hash冲突，使得底层的链表或者是红黑树的高度比较低，提升了空间效率。
  当需要一个较大空间时，最好给一个大的初始容量，避免rehash。
• 基本操作 (get and put) 恒定时间性能：O(log n)；
• 使用相同的键存储值会直接降低hashtable的效率。为了减轻这样的情况，会对key进行比较，确保key的重复性低，但是这样也会降低性能。
• hashmap不同步，需要自行在外部同步。一般是将map封装在一个对象中，然后对这个对象进行同步；也可以如下确保同步：

	Map m = Collections.synchronizedMap(new HashMap(...));

大致相当于 hashtable, 只是hashmap不同步, 并允许空值；

• 当hashmap过大时（链表长度大于8）会转为红黑树，支持更快的查询，树节点的大小是常规节点的两倍。

2、内部结构

这是hashmap的内部结构，用数组加链表的形式，先使用散列，把节点分布到数组的每个位置，发生冲突时，使用链表解决

这里散列的大小为2^n，事实上这并不是一个很好的选择，碰撞概率会增大。一般情况下，散列的大小最好取2的n次方-1（素数）。hashmap这样做是为了之后运算（位运算）方便，同时在hash时选择更好的hash函数，以抵消2的n次方带来的不便。

这是每一个node：

当链表长度大于8时，每一个node都会变成treeNode，形成红黑树。

3、补充

• 要求map中存储的对象有hashcode()和equals()方法，且有不变性，所以使用Integer和String更好，它们都是final，不会变，而且有hashcode()和equals()方法。
• fail-fast机制：map中有一个modcount，用于存储版本号，每次对map进行结构上的修改，modcount就会+1；修改时，检查版本号，如果期待的版本号和当前版本号不同，则直接抛出异常，不再进行后续步骤。问题在于fail-fast并不保证每次都能检查出异常，所以并不能依赖它，hashmap依旧是线程不安全的。
• 序列化的时候，先写入大小，负载因子等参数，再写入每一个节点，读取时按相同顺序。

二、常用方法

1、字段

hashmap中的字段如下，可以在初始化时进行设置，如果不设置，则按照默认的处理

	//大小为2^n，首次使用时初始化，有时长度可以为0
	transient Node<K,V>[] table;
	//缓存节点，AbstractMap字段在keySet() and values()中使用
	transient Set<Entry<K,V>> entrySet;
	//map中存储节点数量
	transient int size;
	//版本号，结构修改时增加，fail-fast机制
	transient int modCount;
	//大于该值，rehash
	int threshold;
	//负载因子
	final float loadFactor;

默认配置

	//默认初始化容量
	static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
	//最大容量
	static final int MAXIMUM_CAPACITY = 1 << 30;
	//负载因子
	static final float DEFAULT_LOAD_FACTOR = 0.75f;
	//链表长度大于该值，转为红黑树
	static final int TREEIFY_THRESHOLD = 8;
	//最多可存储数量：CAPACITY * LOAD_FACTOR。大于该值，rehash。
	static final int UNTREEIFY_THRESHOLD = 6;
	//变成树的最小容量
	static final int MIN_TREEIFY_CAPACITY = 64;

2、计算hash

先得到key的hashcode，然后让高16位和低16位异或，结果就是hash，
index = (n - 1) & hash，也就是hash对表大小取余。

	/*计算hash
	由于map的大小为2^n，更容易出现碰撞，所以需要高位与低位异或，减少碰撞
	*/
	static final int hash(Object key) {
   
	    int h;
	    // >>>：无符号右移16位
	    //高位与低位异或
	    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
	}

3、存入值 put：

afterNodeInsertion，afterNodeAccess这些是linkhashmap会做的事情，此处不讨论

	/** 存入值
	* @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
	*
	*/
	//todo
	final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
	              boolean evict) {
   
	   Node<K,V>[] tab; Node<K,V> p; int n, i;
	   //table为空，resize
	   if ((tab = table) == null || (n = tab.length) == 0)
	       n = (tab = resize()).length;//table的长度
	   //该节点应该存入的位置为空，新建节点，存入
	   if ((p = tab[i = (n - 1) & hash]) == null)
	       tab[i] = newNode(hash, key, value, null);
	   //不为空，p指向链表或红黑树
	   else {
   
	       Node<K,V> e; K k;
	       //判断第一个节点，如果第一个节点就是要存储的节点，将p的值给e
	       if (p.hash == hash &&
	               ((k = p.key) == key || (key != null && key.equals(k))))
	           e = p;
	       //按红黑树处理
	       else if (p instanceof TreeNode)
	           e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
	       else {
   //处理链表
	           //遍历链表
	           for (int binCount = 0; ; ++binCount) {
   
	               //如果没有下一个了，则进行尾插，然后结束
	               if ((e = p.next) == null) {
   
	                   p.next = newNode(hash, key, value, null);
	                   if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
	                       treeifyBin(tab, hash);//转为红黑树
	                   break;
	               }
	               //如果e是要存储的节点，停止
	               if (e.hash == hash &&
	                       ((k = e.key) == key || (key != null && key.equals(k))))
	                   break;
	               p = e