前沿：首先HashMap具体实现是由链表+数组的实现方式，并且采用了动态扩容技术
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE; 注意是transient，非序列化 1.数组还有很多的空间没有被使用，没有被使用到的空间被序列化没有意义 2.不同的虚拟机对于相同 hashCode 产生的 Code 值可能是不一样的
Entry<K,V>是链表和数组的主要组成： 其重要的成员变量是Key，Value，Entry<K,V>next，hash
static class Entry<K,V> implements Map.Entry<K,V> { final K key; V value; Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构 int hash; Entry(int h, K k, V v, Entry<K,V> n) { value = v; next = n; key = k; hash = h; } ```构造如下： 其他组成： transient int size;//实际个数 int capacity;//实际大小 int initialCapacity,//初始的数组大小 int threshold;//capacity*loadFactory。HashMap put新元素后，如果size>threhold，需要扩容
/**负载因子，代表了table的填充度有多少，默认是0.75 加载因子默认为0.75，也就是说大小为16的HashMap，到了第13个元素，就会扩容成32。 */ final float loadFactor;
/*HashMap被改变的次数，由于HashMap非线程安全，在对HashMap进行迭代时，如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），需要抛出异常ConcurrentModificationException/ transient int modCount;
1：构造方法 //主要是对传入的initialCapacity和loadFactor进行参数检验，没有为数组table分配内存空间而是在执行put操作的时候才真正构建table数组
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; threshold = initialCapacity; init();//init方法在HashMap中没有实际实现，不过在其子类如 linkedHashMap中就会有对应实现 }2：put 主要分为四部分： 1：如果table为空，需要创建table 2：计算机hash值和数组的index 3：如果在数组中存在，则替换并返回旧hash 4：如果在数组中不存在，则直接插入数组
public V put(K key, V value) { //如果table数组为空数组{}，进行数组填充（为table分配实际内存空间），入参为threshold，此时threshold为initialCapacity 默认是1<<4(16)==后面会改变== if (table == EMPTY_TABLE) { inflateTable(threshold); } //如果key为null，存储位置为table[0]或table[0]的冲突链上 if (key == null) return putForNullKey(value); int hash = hash(key); int i = indexFor(hash, table.length);//获取在table中的实际位置 for (Entry<K,V> e = table[i]; e != null; e = e.next) { //如果该对应数据已存在，执行覆盖操作。用新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(),hash(),indexFor(),recordAccess(),addEntry()
hash()：转为hash值 addEntry()：加入hash数组，并且根据情况进行扩容
如何初始扩容：
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确定索引：
static int indexFor(int h, int length) { return h & (length-1); }关键点：为什么实际大小总是2的幂？ 我的理解： 原因一： 因为index=hash%length-1 比如对于： length=16 则length-1 =15 即 00001111 length=32 则length-1=31 即 00011111 可以看到，对于一个相同的hash，分别&两个不同的length-1，得到的结果result1,result2 差别就只在右数第5位，相当于扩容后只要修改一位就可以改变索引
原因二: 因为length=2^n，则length-1的位都是保持00001111111的形状，而hash&length-1中，高位不会产生影响，而低位任意一个变化变化都会产生影响，减少冲突的概率。 在h<length的情况下： 对于长度：23 length-1则比特为 10110，则对于结果result=10110 既可以是h=11110 10110 11111 10111 都对应相同的结果冲突增加 而对于长度32 length-1 则比特位11111 ，则对于结果10110 只有h=10110才可以与其对应
其实HashMap还要其他方法，但是感觉关键部分就是上面写的，如果还想加深了解，可以看一下
