HashMap源码解析
JDK1.8源码分析之HashMap
HashMap的数据结构（1.8）
前言
今天来说说HashMap，之前的List，主要是ArrayList、LinkedList，这两者反应了两种思想：
* ArrayList以数组形式实现，顺序插入、查找快，插入、删除较慢
* LinkedList以链表的形式实现，顺序插入、查找较慢，插入、删除方便
然而HashMap是拥有结合上面两种数据结构的优点，它是基于哈希表的Map接口的实现，以key-value的形式存在。
构造图如下：
蓝色线条：继承
绿色线条：接口实现、
正文
要理解HashMap，就必须了解其底层实现，而底层实现最终要的就是其数据结构了。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。
要分析理解HashMap源码之前必须对hashcode进行说明。
源于HashCode的官方文档定义：
hashcode方法返回该对象的哈希码值。支持该方法是为哈希表提供一些优点，如 java.util.Hashtable提供的哈希表。
hashCode的常规协定：
在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
如果根据 equals(Object) 方法，两个对象是相等的，那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。
以下情况不 是必需的：如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是，程序员应该知道，为不相等的对象生成不同整数结果可以提高哈希表的性能。
实际上，由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 JavaTM 编程语言不需要这种实现技巧。）
当equals方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。从上可得到：
1、hashCode的存在主要用于查找的快捷性，如Hashtable、HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的；
2、如果两个对象相同，就适用于equals（Object）方法，那么这两个对象的hashCode一定要相同；
3、如果两个对象的equals方法被重写，那么对象的hashCode尽量重写，并产生hashCode的使用对象，一定要和equals方法中使用的一致；
4、两个对象的hashCode相同，并不一定表示两个对象相同，也就是不一定适用equals（Object）方法，只能说明这两个对象在散列存储结构中，如Hashtable，放在“同一个篮子里”。
HashMap定义
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
HashMap是一个散列表，它的存储的内容就是键值对（key-value）映射。
HashMap继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口
HashMap的实现不是同步的，意味着它不是线程安全的。他的key和value都可以为null。此外HashMap的映射不是有序的。
HashMap的属性
/** * 初始容量为16，容量必须是2的n次幂 */ static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 /** * 最大容量为2的30次方 */ static final int MAXIMUM_CAPACITY = 1 << 30; /** * 默认加载因子为0.75f */ static final float DEFAULT_LOAD_FACTOR = 0.75f;
/** * 数组，长度必须为2的n次幂 */ transient Node<K,V>[] table; /** * Holds cached entrySet(). Note that AbstractMap fields are used * for keySet() and values(). */ transient Set<Map.Entry<K,V>> entrySet; /** * 存储的元素数量 */ transient int size; /** * 用来实现fast-fail机制的 */ transient int modCount; /** * 下次扩容的临界值，size>=threshold就会扩容，threshold等于capacity*load factor (capacity * load factor). * * @serial */ int threshold; /** * 加载因子 * * @serial */ final float loadFactor;
HashMap是通过“拉法链”实现hash表的，它包括几个重要的成员变量：table, size, threshold, loadFactor, modCount。
其中table数组的实现：
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是HashMap的内部类，继承了Map的Entry接口，定义了键key、值value和下一个节点的引用next，以及hash值。
很明确的可以看出Entry的结构，他是一个单线链表的一个节点。也就是说HashMap的底层结构是一个数组，而数组的元素是一个单向链表。
之前介绍的List中，查询的时候需要遍历所有的数组，为了解决这个问题HashMap采用hash算法将key散列为一个int值，这个int值对应到数组的下标，再做查询的时候，拿到key散列值，根据数组下标就能直接找到存储在数组的元素。但是由于hash可能出现相同的散列值，为了解决冲突，HashMap采用将相同的散列值存储到一个链表中，也就是说在一个链表中的元素他们的散列值绝对是相同的。找到数组下标取出链表，再遍历链表是不是比遍历整个数组效率高！！
HashMap构造函数
/** * 构造一个指定初始容量和加载因子的构造函数 */ public HashMap(int initialCapacity, float loadFactor) { //初始容量和加载因子合法性校验 if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor; this.threshold = tableSizeFor(initialCapacity); } /** * 构造一个指定初始容量的构造函数 */ public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } /** * 构造一个默认容量为16，默认加载因子为0.75的HashMap */ public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted } /** * 构造一个指定map的HashMap */ public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); }
/** * 返回一个大于输入参数且最近的2的整数次幂的数 */ 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; }
在这里提到了两个参数：初始容量，加载因子。这两个参数是影响HashMap性能的重要参数，其中容量表示哈希表中桶的数量，初始容量是创建哈希表时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。系统默认负载因子为0.75，一般情况下我们是无需修改的。
API方法
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 */ 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未初始化或者长度为0，进行扩容 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //(n - 1) & hash 确定元素存放在那个桶中，桶为空， // 新生成节点放入，此时这个节点放在数组中 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else {//桶中的元素已经存在 Node<K,V> e; K k; //比较桶中的第一个元素（数组中的节点）的hash值相等，key相等 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) //将第一个元素赋值给e，用e来记录 e = p; //hash值不相等，即key不相等，为红黑树节点 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;//跳出循环 } //判断链表中的节点的key和插入的元素的key是否相等 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break;//相等跳出循环 //用于遍历桶中的链表，与前面的e=p.next结合，可以遍历链表 p = e; } } //在桶中找到key值、hash值与插入元素相等的节点 if (e != null) { // existing mapping for key //记录e的value V oldValue = e.value; //onlyIfAbsent为false或者oldValue为null if (!onlyIfAbsent || oldValue == null) //用新值替换旧值 e.value = value; afterNodeAccess(e);//访问回调 return oldValue;//返回旧值 } } ++modCount;//fast-fail更改 //实际大小大于阈值则扩容 if (++size > threshold) resize(); //插入后回调 afterNodeInsertion(evict); return null; }
扩容
/** * 扩容函数 * * @return the table */ final Node<K,V>[] resize() { //当前table保存 Node<K,V>[] oldTab = table; //保存table大小 int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold;//保存当前阈值 int newCap, newThr = 0; //之前的table大小大于0 if (oldCap > 0) { //之前table大于最大容量 if (oldCap >= MAXIMUM_CAPACITY) { //阈值为最大整形 threshold = Integer.MAX_VALUE; return oldTab; } //容量翻倍，使用左移，效率高 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) //阈值翻倍 newThr = oldThr << 1; // double threshold } //之前阈值大于0 else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; // oldCap = 0并且oldThr = 0，使用缺省值（如使用HashMap()构造函数，之后再插入一个元素会调用resize函数，会进入这一步） else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; 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 = newThr; @SuppressWarnings({"rawtypes","unchecked"}) //初始化table Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; //之前的table已经初始化过了 if (oldTab != null) { //赋值元素重新进行hash for (int j = 0; j < oldCap; ++j) { Node<K,V> 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 { // preserve order Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; // 将同一桶中的元素根据(e.hash & oldCap)是否为0进行分割，分成两个不同的链表，完成rehash do { next = e.next; if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { 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; } } } } } return newTab; }
扩容会伴随一次重新hash分配，并且会遍历hash表中的所有元素，是非常耗时的，所以应进来避免resize（）。
查找方法
/** * 查询方法 */ public V get(Object key) { Node<K,V> e; 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 Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; //table已经初始化，长度大于0，根据hash寻找table中的项也不为空 if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { //桶中第一个元素相等 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; //桶中不止一个节点 if ((e = first.next) != null) { //为红黑树节点 if (first instanceof TreeNode) //在红黑树中找 return ((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); } } return null; }
remove方法
与put方法类似
/** * 删除 */ public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; } /** * Implements Map.remove and related methods * * @param hash hash for key * @param key the key * @param value the value to match if matchValue, else ignored * @param matchValue if true only remove if value is equal * @param movable if false do not move other nodes while removing * @return the node, or null if none */ final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K,V>[] tab; Node<K,V> p; int n, index; if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) { Node<K,V> node = null, e; K k; V v; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p; else if ((e = p.next) != null) { if (p instanceof TreeNode) node = ((TreeNode<K,V>)p).getTreeNode(hash, key); else { do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null); } } if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) { if (node instanceof TreeNode) ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); else if (node == p) tab[index] = node.next; else p.next = node.next; ++modCount; --size; afterNodeRemoval(node); return node; } } return null; }
clear方法
/** * 清除所有元素，并把每个位置置为null */ public void clear() { Node<K,V>[] tab; modCount++; if ((tab = table) != null && size > 0) { size = 0; for (int i = 0; i < tab.length; ++i) tab[i] = null; } }
总结
1、两者最主要的区别在于HashTable是线程安全的，HashMap是非线程安全的。HashTable的实现方法里面添加了synchronized关键字来确保线程同步，因此相对而言HashMap性能可能会高些，若无特殊需求建议使用HashMap，在多线程的环境下使用HashMap则可以使用Collections.synchronizedMap( )方法来获取一个线程安全的集合（Collections.synchronizedMap（）实现原理是Collections定义了一个SynchronizedMap的内部类，这个类实现了Map接口，在调用方法时，使用synchronized来保证线程同步，当然了实际上操作的还是我们传入的HashMap实例，简单说就是Collections.synchronizedMap（）方法帮我们在操作HashMap的时候自动添加了synchronized来实现线程同步，其他类似的Collections.synchronizedxxx（）也是一样的道理）
2、HashMap允许key为null值，而HashTable则不允许。HashMap以null作为key值则总是存储在数组的第一个节点上。
3、HashMap是实现了Map接口，HashTable是实现了Map接口和Dictionary抽象类
4、HashMap的初始容量为16，HashTable为11，两者的加载因子都是0.75。扩容的时候，HashMap是为原来的两倍，HashTable是两倍还要+1.
5、两者的底层实现都是数组+链表+红黑树。
6、两者计算hash值的方法不同：
HashTable是直接用key的hashCode对table的长度进行取模。
int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length;HashMap是key的hashCode与hashCode的高16位做异或运算。
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
https://www.cnblogs.com/leesf456/p/5242233.html
原文: http://tengj.top/2016/04/15/javajh3hashmap/ 作者: 嘟嘟MD
