int index = HashCode(key) % Array.length

1. 第一个属性是默认的初始化容量，表示哈希表的默认长度，当我们在创建HashMap对象的时候未指定容量时，默认的容量就是16。这里多说一句，当我们知道我们的Key-Value对的个数的时候（一般是个数大于16），我们在创建HashMap对象的时候最好就指定容量大小，且一般情况是指定大于Key-Value对的个数且最靠近Key-Value对的个数的2的次幂，比如，我们需要在HashMap中存储27个K-V对，那么大于27且最靠近27的2的次幂就是32，那么我们在创建HashMap对象的时候就可以指定容量为32，这么做的目的就是为了减少HashMap内哈希表的扩容次数，减少不必要的性能损耗。
2. 第二个属性是哈希表的最大容量。
3. 第三个属性默认的负载因子，也就是我们在创建HashMap对象的时候没有指定负载因子，那么就使用这个负载因子，它是哈希表扩容的一个重要参数，当HashMap中存储的K-V对的个数大于等于哈希表容量乘以这个负载因子（size >= capacity * DEFAULT_LOAD_FACTOR）的时候，将触发扩容，且扩容为原容量的两倍。举个例子，当我们创建HashMap对象未指定哈希表容量的时候，也就是使用默认的16，当调用HashMap对象的put方法存储数据的时候，当存储的数量为16*0.75f=12的时候，将触发扩容机制，此时哈希表容量将扩充为32，这也就是在上面第一个属性描述的时候为什么多说一句的原因了。
4. 第四个属性是空的哈希表。
5. 第五个属性是后续操作的哈希表。
6. 第六个属性是HashMap中存储的K-V组合的个数。
7. 第七个属性是扩容阈值，当size >= threshold的时候（实际还需满足有链表的条件），将触发哈希表的扩容机制，threshold = capcity * loadFactor。
8. 第八个属性是是自定义负载因子，当没有指定负载因子的时候，loadFactor = 0.75f。
9. 第九个属性是记录了map新增/删除K-V对，或者内部结构做了调整的次数。其主要作用，是对Map的遍历操作做一致性校验，如果在iterator操作的过程中，map的数值有修改，直接抛出ConcurrentModificationException异常。
10. 第十个属性表示对字符串键的HashMap应用代替哈希函数时，Map内元素个数的默认阈值，目的是为了减少哈希碰撞的概率。

// 该构造方法是第二第三构造方法的底层实现，该构造方法对初始化容量和负载因子进行了一个校验 // 然后将传入的负载因子复制给了loadFactor成员变量 // 将初始化容量赋值给了扩容阈值（扩容临界数值） 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(); }// 指定容量来创建HashMap对象，该变量initialCapacity不一定是初始化哈希表的长度 public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); }// 使用默认的容量16和默认的负载因子0.75f来创建HashMap对象 public HashMap() { this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR); }// 传入一个Map将其转化为HashMap public HashMap(Map m) { // 创建一个HashMap this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR); // 初始化HashMap，重点方法，后面详细介绍 inflateTable(threshold); // 将Map转化为HashMap的具体实现 putAllForCreate(m); }

private void inflateTable(int toSize) { // 计算大于toSize的且最接近toSize的2的N次幂 // 比如toSize=27，那么大于27且最接近27的2的N次幂是32，N=5 int capacity = roundUpToPowerOf2(toSize); // 这里重新计算了threshold，由代码可知，threshold = capacity * loadFactor threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1); // 初始化了哈希表（桶数组） table = new Entry[capacity]; initHashSeedAsNeeded(capacity); }private static int roundUpToPowerOf2(int number) { // assert number >= 0 : "number must be non-negative"; return number >= MAXIMUM_CAPACITY ? MAXIMUM_CAPACITY : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1; }

// 这就是将指定Map转换为HashMap的方法，循环遍历，主要看下面的putForCreate方法 private void putAllForCreate(Map m) { for (Map.Entry e : m.entrySet()) putForCreate(e.getKey(), e.getValue()); }private void putForCreate(K key, V value) { // 计算hash值，如果key==null，那么hash值为0 int hash = null == key ? 0 : hash(key); // 利用hash值和哈希表长度计算当前k-v应在数组的索引下标 int i = indexFor(hash, table.length); // 由于table[i]处可能不止有一个元素（多个会形成一个链表），因此，此处写这样一个循环遍历链表 // 当key存在的时候，直接将key的值设置为新值 for (Entry e = table[i]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { e.value = https://www.it610.com/article/value; return; } }// 当key在当前数组和所有链表中不存在的时候，就在table的指定位置创建一个Entry createEntry(hash, key, value, i); }void createEntry(int hash, K key, V value, int bucketIndex) { // 获取当前数组的Entry链表头节点，并赋值给Entry e Entry e = table[bucketIndex]; // 创建一个新的Entry节点对象，并作为新的头节点，将老的头节点赋值给新头节点的next属性 // 这一点很重要，可以看Entry的构造方法，这表明了JDK7是头节点插入链表 table[bucketIndex] = new Entry<>(hash, key, value, e); // Entry对象数量+1 size++; }

public V put(K key, V value) { // 首先判断哈希表table是否是空表，第一次put的时候，必然是空表，那么就进行初始化 // 如果我们使用的是HashMap的无参构造方法创建的对象，那么threshold就是16， // 上面已经分析过inflateTable方法了，它主要是计算了最合适的capacity=16，threshold=12 // 并创建了一个新的Entry[16]赋值给了table，也就是开辟了内存空间 // 从第二次put开始，table就不再是空数组了 if (table == EMPTY_TABLE) { inflateTable(threshold); } // 判断key是否为null，如果为null，那么就执行存储key为null的逻辑，后续分析putForNullKey方法 if (key == null) return putForNullKey(value); // 计算key的hash值 int hash = hash(key); // 根据hash值和哈希表长度来计算当前K-V在哈希表中的索引下标 int i = indexFor(hash, table.length); // 找到下标之后，获取当前下标对应的是否有Entry对象，如果有，那么就遍历这个链表 // 判断链表中是否已经包含当前key了，如果包含，那么就将key对应的值替换成新值，并返回旧值 for (Entry e = table[i]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = https://www.it610.com/article/e.value; e.value = value; e.recordAccess(this); return oldValue; } } // 能运行到这一步，说明上述链表不存在或者链表中没有对应的key // 那么就需要添加新的Entry对象到指定的索引位置i上 // 记住这里也是头节点插入 modCount++; // 新增Entry，不仅新增，而且还担任了扩容的担子，后续详细分析 addEntry(hash, key, value, i); // 新增Entry对象，返回null return null; }

private V putForNullKey(V value) { for (Entry e = table[0]; e != null; e = e.next) { if (e.key == null) { V oldValue = https://www.it610.com/article/e.value; e.value = value; e.recordAccess(this); return oldValue; } } modCount++; addEntry(0, null, value, 0); return null; }

void addEntry(int hash, K key, V value, int bucketIndex) { // 扩容的条件：1. size >= threshold // 2. null != table[bucketIndex] // 两个条件同时满足才会进行扩容 if ((size >= threshold) && (null != table[bucketIndex])) { // 扩容为原来容量的两倍，具体代码后续分析 resize(2 * table.length); // 重新计算当前要新增的K-V对在新的哈希表中的索引位置 hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); }// 创建Entry对象，并插入到指定位置的头节点 createEntry(hash, key, value, bucketIndex); }

• 扩容条件必须同时满足size >= threshold和null != table[bucketIndex]
• put键为null的K-V对的时候永远不会发生扩容

• 扩容条件必须同时满足size >= threshold和null != table[bucketIndex]
• put键为null的K-V对的时候永远不会发生扩容

void resize(int newCapacity) { Entry[] oldTable = table; int oldCapacity = oldTable.length; // 如果老数组的容量达到了最大，那么就将threshold设置为最大值，且不会再发生扩容 if (oldCapacity == MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return; }// 创建一个新的哈希表，容量是原来哈希表的两倍，也就是newCapacity = 2 * oldCapacity Entry[] newTable = new Entry[newCapacity]; // 将重新计算所有Entry对象的下标，并重新排列各个Entry对象的位置，稍后分析transfer方法实现 transfer(newTable, initHashSeedAsNeeded(newCapacity)); table = newTable; // 重新计算新的扩容阈值threshold threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); }

void transfer(Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; // 遍历老的table，遍历到每一个bucket的时候，都会将bucket上链表的节点都遍历一遍 for (Entry e : table) { while(null != e) { Entry next = e.next; // 重新计算hash if (rehash) { e.hash = null == e.key ? 0 : hash(e.key); } // 重新计算下标 int i = indexFor(e.hash, newCapacity); // 头节点插入链表 e.next = newTable[i]; newTable[i] = e; // 继续原链表的下一个节点 e = next; } } }

public V get(Object key) { // 首先判断key是否为null，如果为null，那么直接获取哈希表的下标为0的位置的Entry对象 if (key == null) return getForNullKey(); // 当key != null，命中到哈希表中的某个下标位置后，遍历链表来获取key相同的entry对象 Entry entry = getEntry(key); // 处理结果并返回，如果找到就返回对应的值，如果没有匹配到直接返回null return null == entry ? null : entry.getValue(); }// 处理key = null的值问题 private V getForNullKey() { if (size == 0) { return null; } // 返回哈希表中下标为0的Entry对象并处理返回结果 for (Entry e = table[0]; e != null; e = e.next) { if (e.key == null) return e.value; } return null; }// 遍历链表匹配到相同key的Entry对象并返回该Entry对象的value值 final Entry getEntry(Object key) { if (size == 0) { return null; }int hash = (key == null) ? 0 : hash(key); for (Entry 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; }

• 方式一：迭代器模式

Map map = new HashMap<>(16); Iterator iterator = map.entrySet().iterator(); while (iterator.hasNext()) { Map.Entry next = iterator.next(); System.out.println(next.getKey() + ":" + next.getValue()); }

• 方式二：遍历Set>方式

Map map = new HashMap<>(16); for (Map.Entry entry : map.entrySet()) { System.out.println(entry.getKey() + ":" + entry.getValue()); }

• 方式三：forEach方式（JDK8特性，lambda）

Map map = new HashMap<>(16); map.forEach((key, value) -> System.out.println(key + ":" + value));

• 方式四：keySet方式

Map map = new HashMap<>(16); Iterator keyIterator = map.keySet().iterator(); while (keyIterator.hasNext()) { String key = keyIterator.next(); System.out.println(key + ":" + map.get(key)); }

推荐阅读

• 

  每天都吃鸡蛋羹好么
• 

  手机|1亿像素还不是尽头！小米2亿像素手机曝光：或明年下半年发布
• 

  鲁大师1
• 

  何以解忧下一句是什么[微笑]
• 

  华为cbg是什么的缩写 华为的cnbg和cbg是什么
• 

  淘宝消息怎么快速删除 淘宝消息快速删除方法
• 

  爱普生4168固件下载
• 

  《海贼王》里除了四皇之外谁的赏金最高？
• 

  指数缩量十字星后期将如何演绎？
• 

  量比是什么意思,换手率多少才合适? 量比是什么意思
• 

  我的世界指令大全最新 我的世界指令大全最新手机版
• 

  了解微信数据分析方法,微信视频号怎么看数据分析
• 

  在自家阳台怎样种蒜苗 自家阳台种蒜苗的方法
• 

  拍摄什么颜色镜头好，镜头里什么颜色好看
• 

  gla怎么样 gla怎么样换发动机机脚胶
• 

  国与国之间能够有友谊么？是盟友更靠谱还是\＂友谊\＂更靠谱？
• 

  三菱plc编程技巧大全，三菱plc编程怎么编
• 

  视频中贴广告 视频贴片广告摄影
• 

  蘑菇拌饭
• 

  蚂蚁庄园新蛋卡是什么？蚂蚁庄园新蛋卡怎么获得？

• 深入理解Go之generate
• 考研英语阅读终极解决方案——阅读理解如何巧拿高分
• 由浅入深理解AOP
• 逻辑回归的理解与python示例
• 【1057快报】深入机关，走下田间，交通普法，共创文明
• 生发知识，带你深入了解
• 「按键精灵安卓版」关于全分辨率脚本的一些理解（非游戏app）
• 深入理解|深入理解 Android 9.0 Crash 机制（二）
• 不理解句意，你还想做对所有GRE填空题（）
• 深入浅出谈一下有关分布式消息技术（Kafka）