本篇介绍的HashMap综合了ArrayList和LinkedList这两个集合的优势，它的底层是基于哈希表实现的，如果不考虑哈希冲突的话，HashMap在增删改查操作上的时间复杂度都能够达到惊人的O(1)。
对于HashMap类源码中开头注释翻译：
HashMap基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
值得注意的是HashMap不是线程安全的，如果想要线程安全的HashMap，可以通过Collections类的静态方法synchronizedMap获得线程安全的HashMap。
一、HashMap的数据结构
HashMap的底层主要是基于数组和链表来实现的，它之所以有相当快的查询速度主要是因为它是通过计算散列码来决定存储的位置。HashMap中主要是通过key的hashCode来计算hash值的，只要hashCode相同，计算出来的hash值就一样。如果存储的对象对多了，就有可能不同的对象所算出来的hash值是相同的，这就出现了所谓的hash冲突。学过数据结构的同学都知道，解决hash冲突的方法有很多，HashMap底层是通过链表来解决hash冲突的。如图：
图中，0~15部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的头节点，链表是用来解决冲突的，如果不同的key映射到了数组的同一位置处，就将其放入单链表中。
从上图我们可以发现哈希表是由数组+链表组成的，一个长度为16的数组中，每个元素存储的是一个链表的头结点Bucket桶。那么这些元素是按照什么样的规则存储到数组中呢。一般情况是通过hash(key)%len获得，也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表中，12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存储在数组下标为12的位置。
HashMap其实也是一个线性的数组实现的,所以可以理解为其存储数据的容器就是一个线性数组。这可能让我们很不解，一个线性的数组怎么实现按键值对来存取数据呢？
首先HashMap里面实现一个静态内部类Entry，其重要的属性有 key , value, next，从属性key,value我们就能很明显的看出来Entry就是HashMap键值对实现的一个基础bean，我们上面说到HashMap的基础就是一个线性数组，这个数组就是Entry[]，Map里面的内容都保存在Entry[]里面。
我们看看HashMap中Entry类的代码：
1 /** Entry是单向链表。 2 * 它是 “HashMap链式存储法”对应的链表。 3 *它实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数 4 **/ 5 static class Entry<K,V> implements Map.Entry<K,V> { 6 final K key; 7 V value; 8 // 指向下一个节点 9 Entry<K,V> next; 10 final int hash; 11 12 // 构造函数。 13 // 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)" 14 Entry(int h, K k, V v, Entry<K,V> n) { 15 value = v; 16 next = n; 17 key = k; 18 hash = h; 19 } 20 21 public final K getKey() { 22 return key; 23 } 24 25 public final V getValue() { 26 return value; 27 } 28 29 public final V setValue(V newValue) { 30 V oldValue = value; 31 value = newValue; 32 return oldValue; 33 } 34 35 // 判断两个Entry是否相等 36 // 若两个Entry的“key”和“value”都相等，则返回true。 37 // 否则，返回false 38 public final boolean equals(Object o) { 39 if (!(o instanceof Map.Entry)) 40 return false; 41 Map.Entry e = (Map.Entry)o; 42 Object k1 = getKey(); 43 Object k2 = e.getKey(); 44 if (k1 == k2 || (k1 != null && k1.equals(k2))) { 45 Object v1 = getValue(); 46 Object v2 = e.getValue(); 47 if (v1 == v2 || (v1 != null && v1.equals(v2))) 48 return true; 49 } 50 return false; 51 } 52 53 // 实现hashCode() 54 public final int hashCode() { 55 return (key==null ? 0 : key.hashCode()) ^ 56 (value==null ? 0 : value.hashCode()); 57 } 58 59 public final String toString() { 60 return getKey() + "=" + getValue(); 61 } 62 63 // 当向HashMap中添加元素时，绘调用recordAccess()。 64 // 这里不做任何处理 65 void recordAccess(HashMap<K,V> m) { 66 } 67 68 // 当从HashMap中删除元素时，绘调用recordRemoval()。 69 // 这里不做任何处理 70 void recordRemoval(HashMap<K,V> m) { 71 } 72 }
HashMap其实就是一个Entry数组，Entry对象中包含了键和值，其中next也是一个Entry对象，它就是用来处理hash冲突的，形成一个链表。
二、HashMap的源码分析
1、关解属性
HashMap类中的一些关解属性：
1 transient Entry[] table;//存储元素的实体数组 2 3 transient int size;//存放元素的个数 4 5 int threshold; //临界值 当实际大小超过临界值时，会进行扩容threshold = 加载因子*容量 6 7 final float loadFactor; //加载因子 8 9 transient int modCount;//被修改的次数
其中loadFactor加载因子是表示Hsah表中元素的填满的程度.
若: 加载因子越大,填满的元素越多,好处是,空间利用率高了, 但: 冲突的机会加大了.链表长度会越来越长,查找效率降低。
反之, 加载因子越小,填满的元素越少,好处是:冲突的机会减小了, 但: 空间浪费多了.表中的数据将过于稀疏（很多空间还没用，就开始扩容了）
冲突的机会越大,则查找的成本越高.
因此,必须在 "冲突的机会"与"空间利用率"之间寻找一种平衡与折衷. 这种平衡与折衷本质上是数据结构中有名的"时-空"矛盾的平衡与折衷.
如果机器内存足够，并且想要提高查询速度的话可以将加载因子设置小一点；相反如果机器内存紧张，并且对查询速度没有什么要求的话可以将加载因子设置大一点。不过一般我们都不用去设置它，让它取默认值0.75就好了
2、构造方法
1 public HashMap(int initialCapacity, float loadFactor) { 2 //确保数字合法 3 if (initialCapacity < 0) 4 throw new IllegalArgumentException("Illegal initial capacity: " + 5 initialCapacity); 6 if (initialCapacity > MAXIMUM_CAPACITY) 7 initialCapacity = MAXIMUM_CAPACITY; 8 if (loadFactor <= 0 || Float.isNaN(loadFactor)) 9 throw new IllegalArgumentException("Illegal load factor: " + 10 loadFactor); 11 12 // Find a power of 2 >= initialCapacity 13 int capacity = 1; //初始容量 14 while (capacity < initialCapacity) //确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂 15 capacity <<= 1; 16 17 this.loadFactor = loadFactor; 18 threshold = (int)(capacity * loadFactor); 19 table = new Entry[capacity]; 20 init(); 21 } 22 23 public HashMap(int initialCapacity) { 24 this(initialCapacity, DEFAULT_LOAD_FACTOR); 25 } 26 27 public HashMap() { 28 this.loadFactor = DEFAULT_LOAD_FACTOR; 29 threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR); 30 table = new Entry[DEFAULT_INITIAL_CAPACITY]; 31 init(); 32 }
参数解释：
HashMap 包含如下几个构造器：
HashMap()：构建一个初始容量为 16，加载因子为 0.75 的 HashMap。
HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。
HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的加载因子创建一个 HashMap。
HashMap的基础构造器HashMap(int initialCapacity, float loadFactor)带有两个参数，它们是初始容量initialCapacity和加载因子loadFactor。
initialCapacity：HashMap的最大容量，即为底层数组的长度。
loadFactor：加载因子loadFactor定义为：散列表的实际元素数目(n)/ 散列表的容量(m)。
加载因子衡量的是一个散列表的空间的使用程度，加载因子越大表示散列表的装填程度越高，反之愈小。
对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果加载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果加载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。
HashMap的实现中，通过threshold字段来判断HashMap的最大容量：
threshold = (int)(capacity * loadFactor);
我们可以看到在构造HashMap的时候如果我们指定了加载因子和初始容量的话就调用第一个构造方法，否则的话就是用默认的。默认初始容量为16，默认加载因子为0.75。
我们可以看到上面代码中13-15行，这段代码的作用是确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂，至于为什么要把容量设置为2的n次幂，我们等下再细说。
现在重点分析下HashMap中用的最多的两个方法put() 和 get()
3、HashMap的数据存储
先来看看HashMap类的put方法：
1 public V put(K key, V value) { 2 // 若“key为null”，则将该键值对添加到table[0]中。 3 if (key == null) 4 return putForNullKey(value); 5 // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。 6 int hash = hash(key.hashCode()); 7 //搜索指定hash值在对应table中的索引 8 int i = indexFor(hash, table.length); 9 // 循环遍历Entry数组,若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！ 10 for (Entry<K,V> e = table[i]; e != null; e = e.next) { 11 Object k; 12 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { //如果key相同则覆盖并返回旧值 13 V oldValue = e.value; 14 e.value = value; 15 e.recordAccess(this); 16 return oldValue; 17 } 18 } 19 //修改次数+1 20 modCount++; 21 //将key-value添加到table[i]处 22 addEntry(hash, key, value, i); 23 return null; 24 }
上面程序中用到了一个重要的内部接口：Map.Entry，每个 Map.Entry 其实就是一个 key-value 对。从上面程序中可以看出：当系统决定存储 HashMap 中的 key-value 对时，完全没有考虑 Entry 中的 value，仅仅只是根据 key 来计算并决定每个 Entry 的存储位置。这也说明了前面的结论：我们完全可以把 Map 集合中的 value 当成 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里即可。
我们慢慢的来分析这个函数，第3和4行的作用就是处理key值为null的情况，我们看看putForNullKey(value)方法：
1 private V putForNullKey(V value) { 2 for (Entry<K,V> e = table[0]; e != null; e = e.next) { 3 if (e.key == null) { //如果有key为null的对象存在，则覆盖掉 4 V oldValue = e.value; 5 e.value = value; 6 e.recordAccess(this); 7 return oldValue; 8 } 9 } 10 modCount++; 11 addEntry(0, null, value, 0); //如果键为null的话，则hash值为0 12 return null; 13 }
注意：如果key为null的话，hash值为0，对象存储在数组中索引为0的位置。即table[0]
我们再回去看看put方法中第6行，它是通过key的hashCode值计算hash码，下面是计算hash码的函数：
//计算hash值的方法 通过键的hashCode来计算 static int hash(int h) { // This function ensures that hashCodes that differ only by // constant multiples at each bit position have a bounded // number of collisions (approximately 8 at default load factor). h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); }
得到hash码之后就会通过hash码去计算出应该存储在数组中的索引，计算索引的函数如下：
static int indexFor(int h, int length) { //根据hash值和数组长度算出索引值 return h & (length-1); //这里不能随便算取，用hash&(length-1)是有原因的，这样可以确保算出来的索引是在数组大小范围内，不会超出 }
这个我们要重点说下，我们一般对哈希表的散列很自然地会想到用hash值对length取模（即除法散列法），Hashtable中也是这样实现的，这种方法基本能保证元素在哈希表中散列的比较均匀，但取模会用到除法运算，效率很低，HashMap中则通过h&(length-1)的方法来代替取模，同样实现了均匀的散列，但效率要高很多，这也是HashMap对Hashtable的一个改进。
接下来，我们分析下为什么哈希表的容量一定要是2的整数次幂。首先，length为2的整数次幂的话，h&(length-1)就相当于对length取模，这样便保证了散列的均匀，同时也提升了效率；其次，length为2的整数次幂的话，为偶数，这样length-1为奇数，奇数的最后一位是1，这样便保证了h&(length-1)的最后一位可能为0，也可能为1（这取决于h的值），即与后的结果可能为偶数，也可能为奇数，这样便可以保证散列的均匀性，而如果length为奇数的话，很明显length-1为偶数，它的最后一位是0，这样h&(length-1)的最后一位肯定为0，即只能为偶数，这样任何hash值都只会被散列到数组的偶数下标位置上，这便浪费了近一半的空间，因此，length取2的整数次幂，是为了使不同hash值发生碰撞的概率较小，这样就能使元素在哈希表中均匀地散列。
根据上面 put 方法的源代码可以看出，当程序试图将一个key-value对放入HashMap中时，程序首先根据该 key 的 hashCode() 返回值决定该 Entry 的存储位置：
具体说明继续看 addEntry() 方法的说明
void addEntry(int hash, K key, V value, int bucketIndex) { Entry<K,V> e = table[bucketIndex]; //如果要加入的位置有值，将该位置原先的值设置为新entry的next,也就是新entry链表的下一个节点 table[bucketIndex] = new Entry<>(hash, key, value, e); if (size++ >= threshold) //如果大于临界值就扩容 resize(2 * table.length); //以2的倍数扩容 }
参数bucketIndex就是indexFor函数计算出来的索引值，第2行代码是取得数组中索引为bucketIndex的Entry对象，第3行就是用hash、key、value构建一个新的Entry对象放到索引为bucketIndex的位置，并且将该位置原先的对象设置为新对象的next构成链表。
第4行和第5行就是判断put后size是否达到了临界值threshold，如果达到了临界值就要进行扩容，HashMap扩容是扩为原来的两倍。
4、HashMap的数组扩容
重新调整HashMap的大小，newCapacity是调整后的单位
1 void resize(int newCapacity) { 2 Entry[] oldTable = table; 3 int oldCapacity = oldTable.length; 4 if (oldCapacity == MAXIMUM_CAPACITY) { 5 threshold = Integer.MAX_VALUE; 6 return; 7 } 8 9 Entry[] newTable = new Entry[newCapacity]; 10 transfer(newTable);//用来将原先table的元素全部移到newTable里面 11 table = newTable; //再将newTable赋值给table 12 threshold = (int)(newCapacity * loadFactor);//重新计算临界值 13 }
新建了一个HashMap的底层数组，上面代码中第10行为调用transfer方法，将HashMap的全部元素添加到新的HashMap中,并重新计算元素在新的数组中的索引位置。
当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，数组扩容这个操作也会出现在ArrayList中，这是一个常用的操作，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize
那么HashMap什么时候进行扩容呢？当HashMap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小为16，那么当HashMap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，扩容是需要进行数组复制的，复制数组是非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。
5、HashMap的数据读取
1 public V get(Object key) { 2 if (key == null) 3 return getForNullKey(); 4 int hash = hash(key.hashCode()); 5 for (Entry<K,V> e = table[indexFor(hash, table.length)]; 6 e != null; 7 e = e.next) { 8 Object k; 9 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) 10 return e.value; 11 } 12 return null; 13 }
有了上面存储时的hash算法作为基础，理解起来这段代码就很容易了。从上面的源代码中可以看出：从HashMap中get元素时，首先计算key的hashCode，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。
归纳起来简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据hash算法来决定其在数组中的存储位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry时，也会根据hash算法找到其在数组中的存储位置，再根据equals方法从该位置上的链表中取出该Entry。
原文：https://www.cnblogs.com/oneBreeze1855/p/9514482.html