// 存放具体元素的集合transient Set> entrySet;

// 存放元素的个数，注意这个不等于数组的长度 transient int size;

// 每次扩容和更改 map 结构的计数器 transient int modCount;

// 临界值 当实际大小（容量*负载因子）超过临界值时，会进行扩容int threshold;

// 负载因子final float loadFactor; // 0.75f

// 构造方法，构造一个带指定初始容量和负载因子的空HashMapHashMap(int initialCapacity, float loadFactor);

例如：负载因子是0.4。 那么16*0.4--->6 如果数组中满6个空间就扩容会造成数组利用率太低了。
负载因子是0.9。 那么16*0.9--->14 那么这样就会导致链表有点多了，导致查找元素效率低。

static class Node implements Map.Entry {final int hash; // hash用来存储key计算得来的hash值final K key; // 键V value; // 值Node next; // 下一个node节点Node(int hash, K key, V value, Node next) {this.hash = hash; this.key = key; this.value = https://www.it610.com/article/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() {// 调用底层c++ 返回Key/Value的哈希码值，如果此对象为null,则返回0return Objects.hashCode(key) ^ Objects.hashCode(value); // 将Key/Vaule}public final V setValue(V newValue) {V oldValue = https://www.it610.com/article/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; }}

// 位于HashMap中,文章接下来会逐步分析static final class TreeNode extends LinkedHashMap.Entry {TreeNode parent; // red-black tree linksTreeNode left; TreeNode right; TreeNode prev; // needed to unlink next upon deletionboolean red; }// 位于LinkedHashMap中，典型的双向链表节点，这个类之后会单独发文章论述static class Entry extends HashMap.Node {Entry before, after; Entry(int hash, K key, V value, Node next) {super(hash, key, value, next); }}

public HashMap() {// 将默认的负载因子0.75赋值给loadFactor，并没有创建数组this.loadFactor = DEFAULT_LOAD_FACTOR; }

// 指定“容量大小”的构造函数public HashMap(int initialCapacity) {this(initialCapacity, DEFAULT_LOAD_FACTOR); }

/*指定“容量大小”和“负载因子”的构造函数initialCapacity：指定的容量loadFactor:指定的负载因子*/public HashMap(int initialCapacity, float loadFactor) {// 判断初始化容量initialCapacity是否小于0if (initialCapacity < 0)// 如果小于0，则抛出非法的参数异常IllegalArgumentExceptionthrow new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); // 判断初始化容量initialCapacity是否大于集合的最大容量MAXIMUM_CAPACITYif (initialCapacity > MAXIMUM_CAPACITY)// 如果超过MAXIMUM_CAPACITY，会将MAXIMUM_CAPACITY赋值给initialCapacityinitialCapacity = MAXIMUM_CAPACITY; // 判断负载因子loadFactor是否小于等于0或者是否是一个非数值if (loadFactor <= 0 || Float.isNaN(loadFactor))// 如果满足上述其中之一，则抛出非法的参数异常IllegalArgumentExceptionthrow new IllegalArgumentException("Illegal load factor: " + loadFactor); // 将指定的负载因子赋值给HashMap成员变量的负载因子loadFactorthis.loadFactor = loadFactor; // 一般不建议修改默认的负载因子this.threshold = tableSizeFor(initialCapacity); } // 最后调用了tableSizeFor，来看一下方法实现：/*返回比指定cap容量大的最小2的n次幂数：前面第一遍讲述的应该有些小伙伴难以理解，这里我在举例解析一下：-------------------------------------------------------首先假定传入的cap = 10则，n = 10 -1 => 9n |= n >>> 1 就等同于 n = (n | n >>> 1),所以：(位运算不懂的可以去看我的《Java基础提高之位运算》这篇文章)9 => 0b10019 >>> 1 => 0b0100 n |= n >>> 1; ===>0b1001 | 0b0100 => 0b1101n |= n >>> 2; ===>0b1101 | 0b0011 => 0b1111n |= n >>> 4; ===>0b1111 | 0b0000 => 0b1111n |= n >>> 8; ===>0b1111 | 0b0000 => 0b1111n |= n >>> 16; ===>0b1111 | 0b0000 => 0b1111得到：0b1111 => 15返回：return 15 + 1 => 16-------------------------------------------------------如果cap 不减去1，即直接使n等于cap的话，int n = cap; 我们继续用上边返回的cap => 16 传入tableSizeFor(int cap)：cap = 16n = 1616 => 0b1000016 >>> 1 => 0b01000n |= n >>> 1; ===>0b10000 | 0b01000 => 0b11000n |= n >>> 2; ===>0b11000 | 0b00110 => 0b11110n |= n >>> 4; ===>0b11110 | 0b00001 => 0b11111n |= n >>> 8; ===>0b11111 | 0b00000 => 0b11111n |= n >>> 16; ===>0b11111 | 0b00000 => 0b11111得到：0b11111 => 31返回 return 31 +1 => 32而实际情况是应该传入cap = 16 , n = cap -1 = 1515 => 0b1111 n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16; 经过上面运算后得到：还是15返回结果：return 15 + 1 = 16所以我们得出结果：防止 cap 已经是 2 的幂数情况下。没有这个减 1 操作，则执行完几条无符号位移或位运算操作之后，返回的cap(32)将是实际所需cap(16)的 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; }

this.threshold = tableSizeFor(initialCapacity) * this.loadFactor;

// 构造一个映射关系与指定 Map 相同的新 HashMap。public HashMap(Map m) {// 负载因子loadFactor变为默认的负载因子0.75this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); }

final void putMapEntries(Map m, boolean evict) {//获取参数集合的长度int s = m.size(); if (s > 0) {//判断参数集合的长度是否大于0if (table == null) { // 判断table是否已经初始化// 未初始化，s为m的实际元素个数float ft = ((float)s / loadFactor) + 1.0F; // 得到新的扩容阈值int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY); // 新的扩容阈值float自动向下转型为int// 计算得到的t大于阈值，则初始化阈值，将其变为符合要求的2的n次幂数if (t > threshold)threshold = tableSizeFor(t); }// 如果table已初始化过了，并且m元素个数大于阈值，进行扩容处理else if (s > threshold)resize(); // 将m中的所有元素添加至HashMap中for (Map.Entry e : m.entrySet()) {K key = e.getKey(); V value = https://www.it610.com/article/e.getValue(); // 得到的key 和 value 放入 hashmapputVal(hash(key), key, value, false, evict); }}}

public V put(K key, V value) {// 调用hash(key)计算出key的hash值return putVal(hash(key), key, value, false, true); }

1. HashMap 只提供了 put 用于添加元素，putVal 方法只是给 put 方法调用的一个方法，并没有提供给用户使用。 所以我们重点看 putVal 方法。
2. 我们可以看到在 putVal 方法中 key 在这里执行了一下 hash 方法,来看一下 hash 方法是如何实现的。

static final int hash(Object key) {
int h;
// 如果key为null，则hash值为0,
// 否则调用key的hashCode()方法计算出key的哈希值然后赋值给h,
// 后与h无符号右移16位后的二进制进行按位异或得到最后的hash值,
// 这样做是为了使计算出的hash更分散
// 为什么要更分散呢？因为越分散，某个桶的链表长度就越短，之后生成的红黑树越少，效率越高
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { ... if ((p = tab[i = (n - 1) & hash]) == null) // 这里的n表示数组长度16 ，公式// (length - 1) & hash = 桶位下标 当数组长度为2的n次幂数时，// 该公式相当于：hash % length 哈希值对数组长度取余// 例如：hash % 32 = hash & (32-1) ...}

1. key.hashCode()；返回散列值也就是 hashcode，假设随便生成的一个值。
2. n 表示数组初始化的长度是 16。
3. &（按位与运算）：运算规则：相同的二进制数位上，都是 1 的时候，结果为 1，否则为0。
4. ^（按位异或运算）：运算规则：相同的二进制数位上，数字相同，结果为 0，不同为 1。

• hash：key 的 hash 值
• key：原始
• keyvalue：要存放的值
• onlyIfAbsent：如果
• true ：代表不更改现有的值
• evict：如果为
• false：表示
• table：为创建状态

public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }static final int hash(Object key) {int h; // 如果key是null 则hash值为0,否则调用key的hashCode()方法,并让高16位参与整个hash异或，如果数组长度比较小的情况下，让高16位也参与寻址，// 寻址公式：(length - 1) & hash // 这样可以使计算出的结果更分散，不容易产生哈希冲突return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {Node[] tab; Node p; int n, i; /*1）transient Node[] table; 表示存储Map集合中元素的数组。2）(tab = table) == null 表示将空的table赋值给tab，然后判断tab是否等于null，第一次肯定是null。3）(n = tab.length) == 0 表示将数组的长度0赋值给n，然后判断n是否等于0，n等于0，由于if判断使用双或，满足一个即可，则执行代码 n = (tab = resize()).length; 进行数组初始化，并将初始化好的数组长度赋值给n。4）执行完n = (tab = resize()).length，数组tab每个空间都是null。*/if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length; /*1）i = (n - 1) & hash 表示计算数组的索引赋值给i，即确定元素存放在哪个桶中。2）p = tab[i = (n - 1) & hash]表示获取计算出的位置的数据赋值给结点p。3) (p = tab[i = (n - 1) & hash]) == null 判断结点位置是否等于null，如果为null，则执行代码：tab[i] = newNode(hash, key, value, null); 根据键值对创建新的结点放入该位置的桶中。小结：如果当前桶没有哈希碰撞冲突，则直接把键值对插入空间位置。*/ if ((p = tab[i = (n - 1) & hash]) == null)// 创建一个新的结点存入到桶中tab[i] = newNode(hash, key, value, null); else {// 执行else说明tab[i]不等于null，表示这个位置已经有值了Node e; K k; /*比较桶中第一个元素(数组中的结点)的hash值和key是否相等1）p.hash == hash ：p.hash表示原来存在数据的hash值hash表示后添加数据的hash值 比较两个hash值是否相等。说明：p表示tab[i]，即 newNode(hash, key, value, null)方法返回的Node对象。Node newNode(int hash, K key, V value, Node next) {return new Node<>(hash, key, value, next); }而在Node类中具有成员变量hash用来记录着之前数据的hash值的。2）(k = p.key) == key ：p.key获取原来数据的key赋值给kkey 表示后添加数据的key比较两个key的地址值是否相等。3）key != null && key.equals(k)：能够执行到这里说明两个key的地址值不相等，那么先判断后添加的key是否等于null，如果不等于null再调用equals方法判断两个key的内容是否相等。*/if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))/*说明：两个元素哈希值相等，并且key的值也相等，将旧的元素整体对象赋值给e，用e来记录*/ e = p; // hash值不相等或者key不相等；判断p是否为红黑树结点else if (p instanceof TreeNode)// 放入树中e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value); // 说明是链表结点else {/*1)如果是链表的话需要遍历到最后结点然后插入2)采用循环遍历的方式，判断链表中是否有重复的key*/for (int binCount = 0; ; ++binCount) {/*1)e = p.next 获取p的下一个元素赋值给e。2)(e = p.next) == null 判断p.next是否等于null，等于null，说明p没有下一个元素，那么此时到达了链表的尾部，还没有找到重复的key,则说明HashMap没有包含该键，将该键值对插入链表中。*/if ((e = p.next) == null) {/*1）创建一个新的结点插入到尾部p.next = newNode(hash, key, value, null); Node newNode(int hash, K key, V value, Node next) {return new Node<>(hash, key, value, next); }注意第四个参数next是null，因为当前元素插入到链表末尾了，那么下一个结点肯定是null。2）这种添加方式也满足链表数据结构的特点，每次向后添加新的元素。*/p.next = newNode(hash, key, value, null); /*1)结点添加完成之后判断此时结点个数是否大于TREEIFY_THRESHOLD临界值8，如果大于则将链表转换为红黑树。2）int binCount = 0 ：表示for循环的初始化值。从0开始计数。记录着遍历结点的个数。值是0表示第一个结点，1表示第二个结点。。。。7表示第八个结点，加上数组中的的一个元素，元素个数是9。TREEIFY_THRESHOLD - 1 --》8 - 1 ---》7如果binCount的值是7(加上数组中的的一个元素，元素个数是9)TREEIFY_THRESHOLD - 1也是7，此时转换红黑树。*/if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st// 转换为红黑树treeifyBin(tab, hash); // 跳出循环break; }/*执行到这里说明e = p.next 不是null，不是最后一个元素。继续判断链表中结点的key值与插入的元素的key值是否相等。*/if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))// 相等，跳出循环/*要添加的元素和链表中的存在的元素的key相等了，则跳出for循环。不用再继续比较了直接执行下面的if语句去替换去 if (e != null) */break; /*说明新添加的元素和当前结点不相等，继续查找下一个结点。用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表*/p = e; }}/*表示在桶中找到key值、hash值与插入元素相等的结点也就是说通过上面的操作找到了重复的键，所以这里就是把该键的值变为新的值，并返回旧值这里完成了put方法的修改功能*/if (e != null) { // 记录e的valueV oldValue = https://www.it610.com/article/e.value; // onlyIfAbsent为false或者旧值为nullif (!onlyIfAbsent || oldValue == null)// 用新值替换旧值// e.value 表示旧值value表示新值 e.value = value; // 访问后回调afterNodeAccess(e); // 返回旧值return oldValue; }}// 修改记录次数++modCount; // 判断实际大小是否大于threshold阈值，如果超过则扩容if (++size> threshold)resize(); // 插入后回调afterNodeInsertion(evict); return null; }

/** * 为什么需要扩容呢？ * 为了解决哈希冲突导致的链化影响查询效率问题，扩容会缓解该问题 */final Node[] resize() {// oldTab：表示扩容前的哈希表数组Node[] oldTab = table; // oldCap：表示扩容之前table数组长度// 如果当前哈希表数组等于null 长度返回0，否则返回当前哈希表数组的长度int oldCap = (oldTab == null) ? 0 : oldTab.length; // oldThr：表示扩容之前的阀值(触发本次扩容的阈值) 默认是12(16*0.75)int oldThr = threshold; // newCap：扩容之后的table散列表数组长度// newThr: 扩容之后，下次再出发扩容的条件(新的扩容阈值)int newCap, newThr = 0; // 如果老的哈希表数组长度oldCap > 0// 如果该条件成立，说明hashMap 中的散列表数组已经初始化过了，是一次正常扩容// 开始计算扩容后的大小if (oldCap > 0) {// 扩容之前的table数组大小已经达到 最大阈值后，则不再扩容// 且设置扩容条件为：int的最大值if (oldCap >= MAXIMUM_CAPACITY) {// 修改阈值为int的最大值threshold = Integer.MAX_VALUE; return oldTab; }// 扩容之前的table数组大小没超过最大值，则扩充为原来的2倍// (newCap = oldCap << 1) < MAXIMUM_CAPACITY 扩大到2倍之后容量要小于最大容量// oldCap >= DEFAULT_INITIAL_CAPACITY 原哈希表数组长度大于等于数组初始化长度16// 如果oldCap 小于默认初始容量16，比如传入的默认容量为8，则不执行下面代码else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)// 新的扩容阈值扩大一倍newThr = oldThr << 1; // double threshold}// 如果老的哈希表数组长度oldCap == 0// 说明hashMap中的散列表还没有初始化，这时候是null// 如果老阈值oldThr大于0 直接赋值/*以下三种情况会直接进入该判断：(即，这时候oldThr扩容阈值已存在)1.new HashMap(initCap,loadFactor); 2.new HashMap(initCap); 3.new HashMap(Map); // 这个传入的map中已经有数据*/else if (oldThr > 0) // 老阈值赋值给新的数组长度newCap = oldThr; // 如果老的哈希表数组长度oldCap == 0// 说明hashMap中的散列表还没有初始化，这时候是null// 此时，老扩容阈值oldThr == 0else { // 直接使用默认值newCap = DEFAULT_INITIAL_CAPACITY; //16newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //12}// 如果执行到这个位置新的扩容阈值newThr还没有得到赋值，则// 需要计算新的resize最大上限if (newThr == 0) {float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?(int)ft : Integer.MAX_VALUE); }// 将新的阀值newThr赋值给thresholdthreshold = newThr; @SuppressWarnings({"rawtypes","unchecked"})// 创建新的散列表// newCap是新的数组长度---> 32Node[] newTab = (Node[])new Node[newCap]; table = newTab; // 说明：hashMap本次扩容之前，table不为nullif (oldTab != null) {// 把每个bucket桶的数据都移动到新的散列表中// 遍历旧的哈希表的每个桶，重新计算桶里元素的新位置for (int j = 0; j < oldCap; ++j) {// 当前node节点Node e; // 说明：此时的当前桶位中有数据，但是数据具体是 // 1.单个数据 、 2.还是链表 、 3.还是红黑树 并不能确定if ((e = oldTab[j]) != null) {// 原来的数据赋值为null 便于GC回收oldTab[j] = null; // 第一种情况：判断数组是否有下一个引用(是否是单个数据)if (e.next == null)// 没有下一个引用，说明不是链表，// 当前桶上只有单个数据的键值对，// 可以将数据直接放入新的散列表中// e.hash & (newCap - 1) 寻址公式得到的索引结果有两种：// 1.和原来旧散列表中的索引位置相同，// 2.原来旧散列表中的索引位置i + 旧容量oldCapnewTab[e.hash & (newCap - 1)] = e; //第二种情况：桶位已经形成红黑树else if (e instanceof TreeNode)// 说明是红黑树来处理冲突的，则调用相关方法把树分开// 红黑树这块，我会单独写一篇博客给大家详细分析一下// 红黑树相关可以先跳过((TreeNode)e).split(this, newTab, j, oldCap); // 第三种情况：桶位已经形成链表else { // 采用链表处理冲突// 低位链表：// 扩容之后数组的下标位置，与当前数组的下标位置一致 时使用Node loHead = null, loTail = null; // 高位链表：扩容之后数组的下标位置等于// 当前数组下标位置 + 扩容之前数组的长度oldCap 时使用Node hiHead = null, hiTail = null; Node next; // 通过上述讲解的原理来计算结点的新位置do {// 原索引next = e.next; // 这里来判断如果等于true // e这个结点在resize之后不需要移动位置// 举例：// 假如hash1-> ...... 0 1111// 假如oldCap=16 -> ...... 1 0000// e.hash & oldCap 结果为0，则// 扩容之后数组的下标位置j，与当前数组的下标位置一致// 使用低位链表if ((e.hash & oldCap) == 0) {if (loTail == null)loHead = e; elseloTail.next = e; loTail = e; }// 举例：// 假如hash2-> ...... 1 1111// 假如oldCap=16 -> ...... 1 0000// e.hash & oldCap 结果不为0，则// 扩容之后数组的下标位置为：// 当前数组下标位置j + 扩容之前数组的长度oldCap// 使用高位链表else {if (hiTail == null)hiHead = e; elsehiTail.next = e; hiTail = e; }} while ((e = next) != null); // 将低位链表放到bucket桶里if (loTail != null) {loTail.next = null; // 索引位置=当前数组下标位置jnewTab[j] = loHead; }// 将高位链表放到bucket里if (hiTail != null) {hiTail.next = null; // 索引位置=当前数组下标位置j + 扩容之前数组的长度oldCapnewTab[j + oldCap] = hiHead; }}}}}// 返回新散列表return newTab; }

// remove方法的具体实现在removeNode方法中，所以我们重点看下removeNode方法// 根据key删除public V remove(Object key) {Node e; return (e = removeNode(hash(key), key, null, false, true)) == null ?null : e.value; }// 根据key,value 删除@Overridepublic boolean remove(Object key, Object value) {return removeNode(hash(key), key, value, true, true) != null; }

final Node removeNode(int hash, Object key, Object value,boolean matchValue, boolean movable) {// 参数：// matchValue 当根据 key和value 删除的时候该参数为true// movable 可以先不用考虑这个参数 // tab：引用当前haashMap中的散列表// p：当前node元素// n：当前散列表数组长度// index：表示寻址结果Node[] tab; Node p; int n, index; // 根据hash找到位置 // 如果当前key映射到的桶不为空if ((tab = table) != null && (n = tab.length) > 0 &&(p = tab[index = (n - 1) & hash]) != null) {// 进入这个if判断内部，说明桶位是有数据的，需要进行查询操作，并且执行删除// node：通过查找得到的要删除的元素// e：表示当前node的下一个元素// k,v 键 值Node node = null, e; K k; V v; // 第一种情况：当前桶位中的元素 即为我们要删除的元素// 如果桶上的结点就是要找的key，则将node指向该结点if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))node = p; // 如果桶位中的头一个元素不是我们要找的元素，且桶位中的e = p.next不为null// 说明该桶位中的节点存在下一个节点else if ((e = p.next) != null) {// 说明：当前桶位，要么是 链表，要么是 红黑树// 第二种情况：判断桶位中是否已经形成了红黑树if (p instanceof TreeNode)// 说明是以红黑树来处理的冲突，则获取红黑树要删除的结点node = ((TreeNode)p).getTreeNode(hash, key); // 第三种情况：桶位中已经形成链表else {// 判断是否以链表方式处理hash冲突// 是的话则通过遍历链表来寻找要删除的结点do {if (e.hash == hash &&((k = e.key) == key ||(key != null && key.equals(k)))) {node = e; break; }p = e; } while ((e = e.next) != null); }}// 比较找到的key的value和要删除的是否匹配if (node != null && (!matchValue || (v = node.value) == value ||(value != null && value.equals(v)))) {// 第一种情况：如果桶位中是红黑树，通过调用红黑树的方法来删除结点if (node instanceof TreeNode)((TreeNode)node).removeTreeNode(this, tab, movable); // 第二种情况：如果桶位中是链表else if (node == p)// 链表删除tab[index] = node.next; // 如果桶位中else// 第三种情况：将当前元素p的下一个元素设置为 要删除元素的 下一个元素p.next = node.next; // 记录修改次数++modCount; // 变动的数量--size; afterNodeRemoval(node); return node; }}return null; }

public V get(Object key) {Node e; return (e = getNode(hash(key), key)) == null ? null : e.value; }

final Node getNode(int hash, Object key) {// tab：引用当前hashMap的散列表// first：桶位中的头元素// e：临时node元素// n：table数组的长度Node[] tab; Node first, e; int n; K k; // 如果哈希表不为空，并且key对应的桶不为空if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {/* 判断数组元素是否相等根据索引的位置检查第一个元素注意：总是检查第一个元素*/// 第一种情况：定位出来的桶位元素 就是我们要get的数据if (first.hash == hash && // always check first node((k = first.key) == key || (key != null && key.equals(k))))return first; // 桶位第一个元素不是我们要找的目标元素，且first.next不为null// 说明当前桶位不止一个元素，可能是链表，也可能是红黑树if ((e = first.next) != null) {// 第二种情况：桶位已经升级成了红黑树// 判断是否是红黑树，是的话调用红黑树中的getTreeNode方法获取结点if (first instanceof TreeNode)// 调用与树相关的方法得到目标元素return ((TreeNode)first).getTreeNode(hash, key); // 第三种情况：桶位已经形成链表do {// 不是红黑树的话，那就是链表结构了// 通过循环的方法判断链表中是否存在该keyif (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))return e; } while ((e = e.next) != null); }}// 如果没找到返回nullreturn null; }

for (String key : map.keySet()) { System.out.println(key); }for (Object vlaue : map.values() { System.out.println(value); }

Iterator iterator = map.entrySet().iterator(); while (iterator.hasNext()) {Map.Entry mapEntry = iterator.next(); System.out.println(mapEntry.getKey() + "---" + mapEntry.getValue()); }

Set keySet = map.keySet(); for (String str : keySet) { System.out.println(str + "---" + map.get(str)); }

default void forEach(BiConsumer action) // BiConsumer接口中的方法： void accept(T t, U u) 对给定的参数执行此操作。参数 t - 第一个输入参数 u - 第二个输入参数

HashMap map = new HashMap(); map.put("001", "zhangsan"); map.put("002", "lisi"); map.forEach((key, value) -> {System.out.println(key + "---" + value); });

推荐阅读

• 

  你错了！喝水其实不如吃水！
• 

  linux命令关机哪个好 linux用来关机的命令
• 

  违章停车发生事故怎么处罚 违章停车导致事故怎样处理
• 

  笨拙的近义词 打量的近义词
• 

  表达对樟树的喜爱的句子 赞美樟树的语句
• 

  二手苹果ee2和苹果fh2哪个好？电气图纸中的FH2是什么意思
• 

  万重山寓意 万重山寓意风水
• 

  流行性感冒|官方：降低重点人群流感疫苗接种费用 提高儿童接种率
• 

  请问桃胶快速泡的方法
• 

  花蛤放自来水里能活12小时吗
• 

  英雄联盟S11神话装备汇总 LOL神话装备属性一览 射手类
• 

  空乘面试考官都会问些什么问题
• 

  男生与女生的爱情观有什么不同？
• 

  青皮的功效与作用 青皮的食用禁忌
• 

  怎么识别普洱茶的年限
• 

  别克gl6用什么防冻液
• 

  怎么查询商标logo 怎么查商标图形，商标查询
• 

  赛博朋克2077朱迪千人千面义务怎么做,朱迪千人千面义务流程详解
• 

  佳能机如何拍海鸥 佳能手动拍海景
• 

  紫薯泥怎么做好吃又简单

• 图书集合完毕
• oracle|oracle java jdk install
• typeScript入门基础介绍
• Android|Android sqlite3数据库入门系列
• Android下的IO库-Okio源码解析(一)|Android下的IO库-Okio源码解析(一) 入门
• 深度学习-入门
• 第三章|第三章 进校园重拾旧梦 登讲台初为人师第一节 接乱班面临考验 ，遇高师指点入门
• iOS开发技术之美—iOS入门技术的基础学习
• OpenCV|OpenCV-Python实战（18）——深度学习简介与入门示例
• 部署专题集合