HashMap转载于这位大佬的文章（炒鸡详细）https://blog.csdn.net/woshimaxiao1/article/details/83661464
public interface Map<K,V> 将键映射到值的对象。 Map不能包含重复的键; 每个键可以映射到最多一个值。
这个接口取代了Dictionary类，Dictionary类是一个完全抽象的类而不是接口。
Map提供了三个集合视图 ，允许将映射内容视为一组键，值集合或键值映射集合。
Map主要实现类有 HashMap，TreeMap，HashTable。
HashMap
HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。（其实所谓Map其实就是保存了两个对象之间的映射关系的一种集合）
//HashMap的主干数组，可以看到就是一个Entry数组，初始值为空数组{}，主干数组的长度一定是2的次幂。
//至于为什么这么做，后面会有详细分析。
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
Entry对象是一个静态内部类，代码如下
static class Entry<K,V> implements Map.Entry<K,V> { final K key; V value; Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构 int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算 /** * Creates new entry. */ Entry(int h, K k, V v, Entry<K,V> n) { value = v; next = n; key = k; hash = h; }
简单来说，HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度为O(n)，首先遍历链表，存在即覆盖，否则新增；对于查找操作来讲，仍需遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。
其他几个重要字段
/**实际存储的key-value键值对的个数*/ transient int size; /**阈值，当table == {}时，该值为初始容量（初始容量默认为16）；当table被填充了，也就是为table分配内存空间后， threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold，后面会详细谈到*/ int threshold; /**负载因子，代表了table的填充度有多少，默认是0.75 加载因子存在的原因，还是因为减缓哈希冲突，如果初始桶为16，等到满16个元素才扩容，某些桶里可能就有不止一个元素了。 所以加载因子默认为0.75，也就是说大小为16的HashMap，到了第13个元素，就会扩容成32。 */ final float loadFactor; /**HashMap被改变的次数，由于HashMap非线程安全，在对HashMap进行迭代时， 如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作）， 需要抛出异常ConcurrentModificationException*/ transient int modCount;
HashMap有四个构造方法，如图
前三个构造方法，就是负载因子和初始容量的有参构造或者默认的取值，只是进行了阈值和负载因子的初始化，并未初始化数组，进行put添加数据才
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;//16 static final float DEFAULT_LOAD_FACTOR = 0.75f;
以map作为参数的构造方法不同于，直接开始了为entry数组分配空间，以及将数组里面的entry链一个一个放入。（判断逻辑是将参数emtry数组元素的key进行hash运算，以及索引计算，确认在新建的entry数组的位置，进行判断是否更替，否则将原数组的emtry链头直接放进去，进行下一个继续判断）是否存在hash冲突？这是初始化，新数组是个空数组，将头元素的信息放入新数组，单个下标所在的链键值对即全部放入了。
public HashMap(Map<? extends K, ? extends V> m) { this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);//首先以传入map的长度为阈值，除以默认的负载因子，计算得到容量大小。与默认值做比较取大的。然后调用其他构造初始化阈值和负载因子 inflateTable(threshold);//初始化阈值和主干数组 putAllForCreate(m);//hash运算，计算索引，填入新的emtry数组数据 }
接着针对put方法（put方法可能会进行emtry数组的初始化）
public V put(K key, V value) { //如果table数组为空数组{}，进行数组填充（为table分配实际内存空间），入参为threshold， //此时threshold为initialCapacity 默认是1<<4(2的4次方=16) if (table == EMPTY_TABLE) { inflateTable(threshold);//相当于初始化数据，设置阈值 } //如果key为null，存储位置为table[0]或table[0]的冲突链上 if (key == null) return putForNullKey(value); int hash = hash(key);//对key的hashcode进一步计算，确保散列均匀 int i = indexFor(hash, table.length);//获取在table中的实际位置 for (Entry<K,V> e = table[i]; e != null; e = e.next) {//取得实际位置的链头，循环判断是否有hash值相等，key值相等的进行替换 //如果该对应数据已存在，执行覆盖操作。用新value替换旧value，并返回旧value Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } modCount++;//保证并发访问时，若HashMap内部结构发生变化，快速响应失败 addEntry(hash, key, value, i);//新增一个entry return null; }
inflateTable这个方法用于为主干数组table在内存中分配存储空间，通过roundUpToPowerOf2(toSize)可以确保capacity为大于或等于toSize的最接近toSize的二次幂，比如toSize=13,则capacity=16;to_size=16,capacity=16;to_size=17,capacity=32.
private void inflateTable(int toSize) { int capacity = roundUpToPowerOf2(toSize);//capacity一定是2的次幂 /**此处为threshold赋值，取capacity*loadFactor和MAXIMUM_CAPACITY+1的最小值， capaticy一定不会超过MAXIMUM_CAPACITY，除非loadFactor大于1 */ threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1); table = new Entry[capacity]; initHashSeedAsNeeded(capacity); }
Hash函数，如果hashcode相同的值，其运算结果应该是相同的，所以会分配到Entry数组相同块。（这里只是返回一个hashcode运算之后的值）
/**这是一个神奇的函数，用了很多的异或，移位等运算 对key的hashcode进一步进行计算以及二进制位的调整等来保证最终获取的存储位置尽量分布均匀*/ final int hash(Object k) { int h = hashSeed; if (0 != h && k instanceof String) { return sun.misc.Hashing.stringHash32((String) k); } h ^= k.hashCode(); h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); }
以上hash函数计算出的值，通过indexFor进一步处理来获取实际的存储位置
/** * 返回数组下标 */ static int indexFor(int h, int length) { return h & (length-1); }
h&（length-1）保证获取的index一定在数组范围内，举个例子，默认容量16，length-1=15（二进制0111），h=18（二进制1010），与运算结果0010,转换成二进制计算为index=2。位运算对计算机来说，性能更高一些（HashMap中有大量位运算）
如果在数组存储下表的链表里找到相同key的，会覆盖value并返回覆盖掉的oldvalue。没有相同的key，即执行addEntry函数添加键值对。
void addEntry(int hash, K key, V value, int bucketIndex) { if ((size >= threshold) && (null != table[bucketIndex])) { resize(2 * table.length);//当size超过临界阈值threshold，并且即将发生哈希冲突时进行扩容 hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); } createEntry(hash, key, value, bucketIndex); }
通过以上代码能够得知，当发生哈希冲突并且size大于阈值的时候，需要进行数组扩容，扩容时，需要新建一个长度为之前数组2倍的新的数组，然后将当前的Entry数组中的元素全部传输过去，扩容后的新数组长度为之前的2倍，而且根据indexFor()函数参数存在数组长度，所以肯定需要重新计算下标，所以扩容相对来说是个耗资源的操作。
看看resize方法究竟干了些什么。
当此映射中的键数达到其阈值,使用容量更大。
如果当前容量是最大容量，则此方法不调整数组大小，但将“阈值”设置为Integer.MAX_VALUE。
新容量新容量，必须是二次幂；必须大于当前容量，除非当前容量是最大容量（在这种情况下为值与此无关）。
void resize(int newCapacity) { Entry[] oldTable = table; int oldCapacity = oldTable.length; if (oldCapacity == MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return; } Entry[] newTable = new Entry[newCapacity]; transfer(newTable, initHashSeedAsNeeded(newCapacity));//第二个返回参数，经过一堆逻辑判断是否重新计算哈希掩码值 table = newTable; threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); }
如果数组进行扩容，数组长度发生变化，而存储位置 index = h&(length-1),index也可能会发生变化，需要重新计算index，我们先来看看transfer这个方法
void transfer(Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; for (Entry<K,V> e : table) { while(null != e) {//循环Entry数组单个链表 Entry<K,V> next = e.next; if (rehash) {//判断是否重新计算哈希掩码值 e.hash = null == e.key ? 0 : hash(e.key); } int i = indexFor(e.hash, newCapacity);//重新计算索引值 e.next = newTable[i];//接下来两步将旧链表的数据从上至下一个一个丢到新链表里面，那么旧链表最上面的就到了新链表最底部（我看的jdk1.7的，查了下网上说的是1.8有区别） newTable[i] = e; e = next; } } }
HashMap的数组长度一定保持2的次幂，比如16的二进制表示为 10000，那么length-1就是15，二进制为01111，同理扩容后的数组长度为32，二进制表示为100000，length-1为31，二进制表示为011111。从下图可以我们也能看到这样会保证低位全为1，而扩容后只有一位差异，也就是多出了最左位的1，这样在通过 h&(length-1)的时候，只要h对应的最左边的那一个差异位为0，就能保证得到的新的数组索引和老数组索引一致(大大减少了之前已经散列良好的老数组的数据位置重新调换)（这段是原博客的个人理解，后续原博客主对长度保持2次幂还有一段解说。。。我没太理解，需要理解的小伙伴可以从顶部的链接去阅读）
hashMap put流程，添加元素，如发生替换会返回被替换掉的value值
1.校验Entry数组是否为空
如果为空初始化Entry数组和阈值（inflateTable方法）
2.校验key值是否为null
默认entry数组第一个元素即是存放key为null，所以源码表现也很简洁
3.调用Hash(Key key)获取hash值
4.根据hash值计算实际在entry数组的索引值 （indexFor(hash,entry.length)）
5.获取到索引值所在entry数组的元素，取出来的是链表的头，循环链表判断key的hash值和key对象是否相等，相等发生替换，返回被替换掉的值
6.如果在5步骤未退出方法，即需要添加而不是替换，导致map内部结构发生变化，即计数器+1
7.调用addEntry(hash, key, value, i)添加元素
get方法
public V get(Object key) { //如果key为null,则直接去table[0]处去检索即可。 if (key == null) return getForNullKey(); Entry<K,V> entry = getEntry(key); return null == entry ? null : entry.getValue(); }
get方法通过key值返回对应value，如果key为null，直接去table[0]处检索。我们再看一下getEntry这个方法
final Entry<K,V> getEntry(Object key) { if (size == 0) { return null; } //通过key的hashcode值计算hash值 int hash = (key == null) ? 0 : hash(key); //indexFor (hash&length-1) 获取最终数组索引，然后遍历链表，通过equals方法比对找出对应记录 for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } return null; }
可以看出，get方法的实现相对简单，key(hashcode)–>hash–>indexFor–>最终索引位置，找到对应位置table[i]，再查看是否有链表，遍历链表，通过key的equals方法比对查找对应的记录。要注意的是，有人觉得上面在定位到数组位置之后然后遍历链表的时候，e.hash == hash这个判断没必要，仅通过equals判断就可以。其实不然，试想一下，如果传入的key对象重写了equals方法却没有重写hashCode，而恰巧此对象定位到这个数组位置，如果仅仅用equals判断可能是相等的，但其hashCode和当前对象不一致，这种情况，根据Object的hashCode的约定，不能返回当前对象，而应该返回null，后面的例子会做出进一步解释。
重写equals方法需同时重写hashCode方法
public class MyTest { private static class Person{ int idCard; String name; public Person(int idCard, String name) { this.idCard = idCard; this.name = name; } @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()){ return false; } Person person = (Person) o; //两个对象是否等值，通过idCard来确定 return this.idCard == person.idCard; } } public static void main(String []args){ HashMap<Person,String> map = new HashMap<Person, String>(); Person person = new Person(1234,"乔峰"); //put到hashmap中去 map.put(person,"天龙八部"); //get取出，从逻辑上讲应该能输出“天龙八部” System.out.println("结果:"+map.get(new Person(1234,"萧峰"))); } } 实际输出结果：null
如果我们已经对HashMap的原理有了一定了解，这个结果就不难理解了。尽管我们在进行get和put操作的时候，使用的key从逻辑上讲是等值的（通过equals比较是相等的），但由于没有重写hashCode方法，所以put操作时，key(hashcode1)–>hash–>indexFor–>最终索引位置 ，而通过key取出value的时候 key(hashcode1)–>hash–>indexFor–>最终索引位置，由于hashcode1不等于hashcode2，导致没有定位到一个数组位置而返回逻辑上错误的值null（也有可能碰巧定位到一个数组位置，但是也会判断其entry的hash值是否相等，上面get方法中有提到。）
所以，在重写equals的方法的时候，必须注意重写hashCode方法，同时还要保证通过equals判断相等的两个对象，调用hashCode方法要返回同样的整数值。而如果equals判断不相等的两个对象，其hashCode可以相同（只不过会发生哈希冲突，应尽量避免）。
posted on
