JDK1.8源码(七)——java.util.HashMap 类
本篇博客咱们来介绍在 JDK1.8 中 HashMap 的源码实现，这也是最经常使用的一个集合。可是在介绍 HashMap 以前，咱们先介绍什么是 Hash表。html
一、哈希表
Hash表也称为散列表，也有直接译做哈希表，Hash表是一种根据关键字值（key - value）而直接进行访问的数据结构。也就是说它经过把关键码值映射到表中的一个位置来访问记录，以此来加快查找的速度。在链表、数组等数据结构中，查找某个关键字，一般要遍历整个数据结构，也就是O(N)的时间级，可是对于哈希表来讲，只是O(1)的时间级。java
好比对于前面咱们讲解的 ArrayList 集合和 LinkedList ，若是咱们要查找这两个集合中的某个元素，一般是经过遍历整个集合，须要O(N)的时间级。node
若是是哈希表，它是经过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫作散列函数，存放记录的数组叫作散列表，只须要O(1)的时间级。算法
①、存放在哈希表中的数据是key-value 键值对，好比存放哈希表的数据为:api
{Key1-Value1,Key2-Value2,Key3-Value3,Key4-Value4,Key5-Value5,Key6-Value6}数组
若是咱们想查找是否存在键值对 Key3-Value3，首先经过 Key3 通过散列函数，获得值 k3，而后经过 k3 和散列表对应的值找到是 Value3。缓存
②、固然也有可能存放哈希表的值只是 Value1,Value2,Value3这种类型：安全
{Value1,Value2,Value3,Value4,Value5,Value6}微信
这时候咱们能够假设 Value1 是等于 Key1的，也就是{Value1-Value1,Value2-Value2,Value3-Value3,Value4-Value4,Value5-Value5,Value6-Value6}能够将 Value1通过散列函数转换成与散列表对应的值。数据结构
你们都用过汉语字典吧，汉语字典的优势是咱们能够经过前面的拼音目录快速定位到所要查找的汉字。当给定咱们某个汉字时，大脑会自动将汉字转换成拼音（若是咱们认识，不认识能够经过偏旁部首），这个转换的过程咱们能够当作是一个散列函数，以后在根据转换获得的拼音找到该字所在的页码，从而找到该汉字。
汉语字典是哈希表的典型实现，可是咱们仔细思考，会发现这样几个问题？
①、为何要有散列函数？
②、多个 key 经过散列函数会获得相同的值，这时候怎么办？
对于第一个问题，散列函数的存在可以帮助咱们更快的肯定key和value的映射关系，试想一下，若是没有汉字和拼音的转换规则（或者汉字和偏旁部首的），给你一个汉字，你该如何从字典中找到该汉字？我想除了遍历整部字典，你没有什么更好的办法。
对于第二个问题，多个 key 经过散列函数获得相同的值，这其实也是哈希表最大的问题——冲突。好比同音字汉字，咱们获得的拼音就会是相同的，那么咱们该如何在字典中存放同音字汉字呢？有两种作法：
第一种是开放地址法，当咱们遇到冲突了，这时候经过另外一种函数再计算一遍，获得相应的映射关系。好比对于汉语字典，一个字 “余”，拼音是“yu”，咱们将其放在页码为567(假设在该位置)，这时候又来了一个汉字“于”，拼音也是“yu”，那么这时候咱们要是按照转换规则，也得将其放在页码为567的位置，可是咱们发现这个页码已经被占用了，这时候怎么办？咱们能够在经过另外一种函数，获得的值加1。那么汉字"于"就会被放在576+1=577的位置。
第二种是链地址法，咱们能够将字典的每一页都当作是一个子数组或者子链表，当遇到冲突了，直接往当前页码的子数组或者子链表里面填充便可。那么咱们进行同音字查找的时候，可能须要遍历其子数组或者子链表。以下图所示：
对于开放地址法，可能会遇到二次冲突，三次冲突，因此须要良好的散列函数，分布的越均匀越好。对于链地址法，虽然不会形成二次冲突，可是若是一次冲突不少，那么会形成子数组或者子链表很长，那么咱们查找所需遍历的时间也会很长。
二、什么是 HashMap？
听名字就知道，HashMap 是一个利用哈希表原理来存储元素的集合。遇到冲突时，HashMap 是采用的链地址法来解决，在 JDK1.7 中，HashMap 是由 数组+链表构成的。可是在 JDK1.8 中，HashMap 是由 数组+链表+红黑树构成，新增了红黑树做为底层数据结构，结构变得复杂了，可是效率也变的更高效。下面咱们来具体介绍在 JDK1.8 中 HashMap 是如何实现的。
三、HashMap定义
HashMap 是一个散列表，它存储的内容是键值对(key-value)映射，并且 key 和 value 均可觉得 null。
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
首先该类实现了一个 Map 接口，该接口定义了一组键值对映射通用的操做。储存一组成对的键-值对象，提供key（键）到value（值）的映射，Map中的key不要求有序，不容许重复。value一样不要求有序，但能够重复。可是咱们发现该接口方法有不少，咱们设计某个键值对的集合有时候并不像实现那么多方法，那该怎么办？
JDK 还为咱们提供了一个抽象类 AbstractMap ，该抽象类继承 Map 接口，因此若是咱们不想实现全部的 Map 接口方法，就能够选择继承抽象类 AbstractMap 。
可是咱们发现 HashMap 类即继承了 AbstractMap 接口，也实现了 Map 接口，这样作难道不是画蛇添足？后面咱们会讲的 LinkedHashSet 集合也有这样的写法。
毕竟 JDK 通过这么多年的发展维护，博主起初也是认为这样是有具体的做用的，后来找了不少资料，发现这其实彻底没有任何做用
据 java 集合框架的创始人Josh Bloch描述，这样的写法是一个失误。在java集合框架中，相似这样的写法不少，最开始写java集合框架的时候，他认为这样写，在某些地方多是有价值的，直到他意识到错了。显然的，JDK的维护者，后来不认为这个小小的失误值得去修改，因此就这样存在下来了。
HashMap 集合还实现了 Cloneable 接口以及 Serializable 接口，分别用来进行对象克隆以及将对象进行序列化。
四、字段属性
//序列化和反序列化时，经过该字段进行版本一致性验证
private static final long serialVersionUID = 362498820763181265L;
//默认 HashMap 集合初始容量为16（必须是 2 的倍数）
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//集合的最大容量，若是经过带参构造指定的最大容量超过此数，默认仍是使用此数
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的填充因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//当桶(bucket)上的结点数大于这个值时会转成红黑树(JDK1.8新增)
static final int TREEIFY_THRESHOLD = 8;
//当桶(bucket)上的节点数小于这个值时会转成链表(JDK1.8新增)
static final int UNTREEIFY_THRESHOLD = 6;
/**(JDK1.8新增)
* 当集合中的容量大于这个值时，表中的桶才能进行树形化 ，不然桶内元素太多时会扩容，
* 而不是树形化 为了不进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
*/
static final int MIN_TREEIFY_CAPACITY = 64;
注意：后面三个字段是 JDK1.8 新增的，主要是用来进行红黑树和链表的互相转换。
/**
* 初始化使用，长度老是 2的幂
*/
transient Node<K,V>[] table;
/**
* 保存缓存的entrySet（）
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 此映射中包含的键值映射的数量。（集合存储键值对的数量）
*/
transient int size;
/**
* 跟前面ArrayList和LinkedList集合中的字段modCount同样，记录集合被修改的次数
* 主要用于迭代器中的快速失败
*/
transient int modCount;
/**
* 调整大小的下一个大小值（容量*加载因子）。capacity * load factor
*/
int threshold;
/**
* 散列表的加载因子。
*/
final float loadFactor;
下面咱们重点介绍上面几个字段：
①、Node<K,V>[] table
咱们说 HashMap 是由数组+链表+红黑树组成，这里的数组就是 table 字段。后面对其进行初始化长度默认是 DEFAULT_INITIAL_CAPACITY= 16。并且 JDK 声明数组的长度老是 2的n次方(必定是合数)，为何这里要求是合数，通常咱们知道哈希算法为了不冲突都要求长度是质数，这里要求是合数，下面在介绍 HashMap 的hashCode() 方法(散列函数)，咱们再进行讲解。
②、size
集合中存放key-value 的实时对数。
③、loadFactor
装载因子，是用来衡量 HashMap 满的程度，计算HashMap的实时装载因子的方法为：size/capacity，而不是占用桶的数量去除以capacity。capacity 是桶的数量，也就是 table 的长度length。
默认的负载因子0.75 是对空间和时间效率的一个平衡选择，建议你们不要修改，除非在时间和空间比较特殊的状况下，若是内存空间不少而又对时间效率要求很高，能够下降负载因子loadFactor 的值；相反，若是内存空间紧张而对时间效率要求不高，能够增长负载因子 loadFactor 的值，这个值能够大于1。
④、threshold
计算公式：capacity * loadFactor。这个值是当前已占用数组长度的最大值。过这个数目就从新resize(扩容)，扩容后的 HashMap 容量是以前容量的两倍
五、构造函数
①、默认无参构造函数
/**
* 默认构造函数，初始化加载因子loadFactor = 0.75
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
无参构造器，初始化散列表的加载因子为0.75
②、指定初始容量的构造函数
/**
*
* @param initialCapacity 指定初始化容量
* @param loadFactor 加载因子 0.75
*/
public HashMap(int initialCapacity, float loadFactor) {
//初始化容量不能小于 0 ，不然抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//若是初始化容量大于2的30次方，则初始化容量都为2的30次方
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//若是加载因子小于0，或者加载因子是一个非数值，抛出异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
// 返回大于等于initialCapacity的最小的二次幂数值。
// >>> 操做符表示无符号右移，高位取0。
// | 按位或运算
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;
}
六、肯定哈希桶数组索引位置
前面咱们讲解哈希表的时候，咱们知道是用散列函数来肯定索引的位置。散列函数设计的越好，使得元素分布的越均匀。HashMap 是数组+链表+红黑树的组合，咱们但愿在有限个数组位置时，尽可能每一个位置的元素只有一个，那么当咱们用散列函数求得索引位置的时候，咱们能立刻知道对应位置的元素是否是咱们想要的，而不是要进行链表的遍历或者红黑树的遍历，这会大大优化咱们的查询效率。咱们看 HashMap 中的哈希算法：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
i = (table.length - 1) & hash;//这一步是在后面添加元素putVal()方法中进行位置的肯定
主要分为三步：
①、取 hashCode 值： key.hashCode()
②、高位参与运算：h>>>16
③、取模运算：(n-1) & hash
这里获取 hashCode() 方法的值是变量，可是咱们知道，对于任意给定的对象，只要它的 hashCode() 返回值相同，那么程序调用 hash(Object key) 所计算获得的 hash码 值老是相同的。
为了让数组元素分布均匀，咱们首先想到的是把得到的 hash码对数组长度取模运算( hash%length)，可是计算机都是二进制进行操做，取模运算相对开销仍是很大的，那该如何优化呢？
HashMap 使用的方法很巧妙，它经过 hash & (table.length -1)来获得该对象的保存位，前面说过 HashMap 底层数组的长度老是2的n次方，这是HashMap在速度上的优化。当 length 老是2的n次方时，hash & (length-1)运算等价于对 length 取模，也就是 hash%length，可是&比%具备更高的效率。好比 n % 32 = n & (32 -1)
这也解释了为何要保证数组的长度老是2的n次方。
再就是在 JDK1.8 中还有个高位参与运算，hashCode() 获得的是一个32位 int 类型的值，经过hashCode()的高16位 异或 低16位实现的：(h = k.hashCode()) ^ (h >>> 16)，主要是从速度、功效、质量来考虑的，这么作能够在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。
下面举例说明下，n为table的长度：
七、添加元素
//hash(key)就是上面讲的hash方法，对其进行了第一步和第二步处理
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
*
* @param hash 索引的位置
* @param key 键
* @param value 值
* @param onlyIfAbsent true 表示不要更改现有值
* @param evict false表示table处于建立模式
* @return
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//若是table为null或者长度为0，则进行初始化
//resize()方法原本是用于扩容，因为初始化没有实际分配空间，这里用该方法进行空间分配，后面会详细讲解该方法
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//注意：这里用到了前面讲解得到key的hash码的第三步，取模运算，下面的if-else分别是 tab[i] 为null和不为null
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);//tab[i] 为null，直接将新的key-value插入到计算的索引i位置
else {//tab[i] 不为null，表示该位置已经有值了
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//节点key已经有值了，直接用新值覆盖
//该链是红黑树
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//该链是链表
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//链表长度大于8，转换成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//key已经存在直接覆盖value
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//用做修改和新增快速失败
if (++size > threshold)//超过最大容量，进行扩容
resize();
afterNodeInsertion(evict);
return null;
}
①、判断键值对数组 table 是否为空或为null，不然执行resize()进行扩容；
②、根据键值key计算hash值获得插入的数组索引i，若是table[i]==null，直接新建节点添加，转向⑥，若是table[i]不为空，转向③；
③、判断table[i]的首个元素是否和key同样，若是相同直接覆盖value，不然转向④，这里的相同指的是hashCode以及equals；
④、判断table[i] 是否为treeNode，即table[i] 是不是红黑树，若是是红黑树，则直接在树中插入键值对，不然转向⑤；
⑤、遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操做，不然进行链表的插入操做；遍历过程当中若发现key已经存在直接覆盖value便可；
⑥、插入成功后，判断实际存在的键值对数量size是否超过了最大容量threshold，若是超过，进行扩容。
⑦、若是新插入的key不存在，则返回null，若是新插入的key存在，则返回原key对应的value值（注意新插入的value会覆盖原value值）
注意1：看第 58,59 行代码：
if (++size > threshold)//超过最大容量，进行扩容
resize();
这里有个考点，咱们知道 HashMap 是由数组+链表+红黑树（JDK1.8）组成，若是在添加元素时，发生冲突，会将冲突的数放在链表上，当链表长度超过8时，会自动转换成红黑树。
那么有以下问题：数组上有5个元素，而某个链表上有3个元素，问此HashMap的 size 是多大？
咱们分析第58,59 行代码，很容易知道，只要是调用put() 方法添加元素，那么就会调用 ++size(这里有个例外是插入重复key的键值对，不会调用，可是重复key元素不会影响size),因此，上面的答案是 7。
注意2：看第 53 、 60 行代码：
afterNodeAccess(e); afterNodeInsertion(evict);
这里调用的该方法，实际上是调用了以下实现方法：
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
这都是一个空的方法实现，咱们在这里能够不用管，可是在后面介绍 LinkedHashMap 会用到，LinkedHashMap 是继承的 HashMap，而且重写了该方法，后面咱们会详细介绍。
八、扩容机制
扩容（resize），咱们知道集合是由数组+链表+红黑树构成，向 HashMap 中插入元素时，若是HashMap 集合的元素已经大于了最大承载容量threshold（capacity * loadFactor），这里的threshold不是数组的最大长度。那么必须扩大数组的长度，Java中数组是没法自动扩容的，咱们采用的方法是用一个更大的数组代替这个小的数组，就比如之前是用小桶装水，如今小桶装不下了，咱们使用一个更大的桶。
JDK1.8融入了红黑树的机制，比较复杂，这里咱们先介绍 JDK1.7的扩容源码，便于理解，而后在介绍JDK1.8的源码。
//参数 newCapacity 为新数组的大小
void resize(int newCapacity) {
Entry[] oldTable = table;//引用扩容前的 Entry 数组
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {//扩容前的数组大小若是已经达到最大(2^30)了
threshold = Integer.MAX_VALUE;///修改阈值为int的最大值(2^31-1)，这样之后就不会扩容了
return;
}
Entry[] newTable = new Entry[newCapacity];//初始化一个新的Entry数组
transfer(newTable, initHashSeedAsNeeded(newCapacity));//将数组元素转移到新数组里面
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);//修改阈值
}
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {//遍历数组
while(null != e) {
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];//标记下一个元素，添加是链表头添加
newTable[i] = e;//将元素放在链上
e = next;//访问下一个 Entry 链上的元素
}
}
}
经过方法咱们能够看到，JDK1.7中首先是建立一个新的大容量数组，而后依次从新计算原集合全部元素的索引，而后从新赋值。若是数组某个位置发生了hash冲突，使用的是单链表的头插入方法，同一位置的新元素老是放在链表的头部，这样与原集合链表对比，扩容以后的可能就是倒序的链表了。
下面咱们在看看JDK1.8的。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;//原数组若是为null，则长度赋值0
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {//若是原数组长度大于0
if (oldCap >= MAXIMUM_CAPACITY) {//数组大小若是已经大于等于最大值(2^30)
threshold = Integer.MAX_VALUE;//修改阈值为int的最大值(2^31-1)，这样之后就不会扩容了
return oldTab;
}
//原数组长度大于等于初始化长度16，而且原数组长度扩大1倍也小于2^30次方
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 阀值扩大1倍
}
else if (oldThr > 0) //旧阀值大于0，则将新容量直接等于就阀值
newCap = oldThr;
else {//阀值等于0，oldCap也等于0（集合未进行初始化）
newCap = DEFAULT_INITIAL_CAPACITY;//数组长度初始化为16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//阀值等于16*0.75=12
}
//计算新的阀值上限
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
//把每一个bucket都移动到新的buckets中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;//元数据j位置置为null，便于垃圾回收
if (e.next == null)//数组没有下一个引用（不是链表）
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)//红黑树
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//原索引
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//原索引+oldCap
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//原索引放到bucket里
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//原索引+oldCap放到bucket里
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
该方法分为两部分，首先是计算新桶数组的容量 newCap 和新阈值 newThr，而后将原集合的元素从新映射到新集合中。
相比于JDK1.7，1.8使用的是2次幂的扩展(指长度扩为原来2倍)，因此，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。咱们在扩充HashMap的时候，不须要像JDK1.7的实现那样从新计算hash，只须要看看原来的hash值新增的那个bit是1仍是0就行了，是0的话索引没变，是1的话索引变成“原索引+oldCap”。
九、删除元素
HashMap 删除元素首先是要找到 桶的位置，而后若是是链表，则进行链表遍历，找到须要删除的元素后，进行删除；若是是红黑树，也是进行树的遍历，找到元素删除后，进行平衡调节，注意，当红黑树的节点数小于 6 时，会转化成链表。
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//(n - 1) & hash找到桶的位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
//若是键的值与链表第一个节点相等，则将 node 指向该节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
//若是桶节点存在下一个节点
else if ((e = p.next) != null) {
//节点为红黑树
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);//找到须要删除的红黑树节点
else {
do {//遍历链表，找到待删除的节点
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//删除节点，并进行调节红黑树平衡
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
注意第 46 行代码
afterNodeRemoval(node);
这也是为实现 LinkedHashMap 作准备的，在这里和上面同样，是一个空方法实现，能够不用管。而在 LinkedHashMap 中进行了重写，用来维护删除节点后，链表的先后关系。
十、查找元素
①、经过 key 查找 value
首先经过 key 找到计算索引，找到桶位置，先检查第一个节点，若是是则返回，若是不是，则遍历其后面的链表或者红黑树。其他状况所有返回 null。
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//根据key计算的索引检查第一个索引
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//不是第一个节点
if ((e = first.next) != null) {
if (first instanceof TreeNode)//遍历树查找元素
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
//遍历链表查找元素
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
②、判断是否存在给定的 key 或者 value
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
public boolean containsValue(Object value) {
Node<K,V>[] tab; V v;
if ((tab = table) != null && size > 0) {
//遍历桶
for (int i = 0; i < tab.length; ++i) {
//遍历桶中的每一个节点元素
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
if ((v = e.value) == value ||
(value != null && value.equals(v)))
return true;
}
}
}
return false;
}
十一、遍历元素
首先构造一个 HashMap 集合：
HashMap<String,Object> map = new HashMap<>();
map.put("A","1");
map.put("B","2");
map.put("C","3");
①、分别获取 key 集合和 value 集合。
//一、分别获取key和value的集合
for(String key : map.keySet()){
System.out.println(key);
}
for(Object value : map.values()){
System.out.println(value);
}
②、获取 key 集合，而后遍历key集合，根据key分别获得相应value
//二、获取key集合，而后遍历key，根据key获得 value
Set<String> keySet = map.keySet();
for(String str : keySet){
System.out.println(str+"-"+map.get(str));
}
③、获得 Entry 集合，而后遍历 Entry
//三、获得 Entry 集合，而后遍历 Entry
Set<Map.Entry<String,Object>> entrySet = map.entrySet();
for(Map.Entry<String,Object> entry : entrySet){
System.out.println(entry.getKey()+"-"+entry.getValue());
}
④、迭代
//四、迭代
Iterator<Map.Entry<String,Object>> iterator = map.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<String,Object> mapEntry = iterator.next();
System.out.println(mapEntry.getKey()+"-"+mapEntry.getValue());
}
基本上使用第三种方法是性能最好的，
第一种遍历方法在咱们只须要 key 集合或者只须要 value 集合时使用；
第二种方法效率很低，不推荐使用；
第四种方法效率也挺好，关键是在遍历的过程当中咱们能够对集合中的元素进行删除。
十二、总结
①、基于JDK1.8的HashMap是由数组+链表+红黑树组成，当链表长度超过 8 时会自动转换成红黑树，当红黑树节点个数小于 6 时，又会转化成链表。相对于早期版本的 JDK HashMap 实现，新增了红黑树做为底层数据结构，在数据量较大且哈希碰撞较多时，可以极大的增长检索的效率。
②、容许 key 和 value 都为 null。key 重复会被覆盖，value 容许重复。
③、非线程安全
④、无序（遍历HashMap获得元素的顺序不是按照插入的顺序）
参考文档：
https://docs.oracle.com/javas...
http://www.importnew.com/2038...
https://www.cnblogs.com/nulll...
本系列教程持续更新，能够微信搜索「 IT可乐 」第一时间阅读。回复《电子书》有我为你们特别筛选的书籍资料
- 1. JDK1.8源码(七)——java.util.HashMap 类
- 2. JDK1.8源码(七)——java.util.HashMap 类，java面试题，java基础笔试题，BAT
- 3. JDK1.8源码(九)——java.util.LinkedHashMap 类
- 4. JDK1.8源码(八)——java.util.HashSet 类
- 5. JDK1.8源码(三)——java.lang.String 类
- 6. JDK1.8源码(四)——java.util.Arrays 类
- 7. JDK1.8源码(五)——java.util.ArrayList 类
- 8. JDK1.8源码(六)——java.util.LinkedList 类
- 9. JDK1.8源码(二)——java.lang.Integer 类
- 10. JDK1.8源码(十)——java.util.LinkedHashSet类
- 更多相关文章...
- • Java操作Neo4j数据库（附带源码） - NoSQL教程
- • Docker 资源汇总 - Docker教程
- • Java Agent入门实战（二）-Instrumentation源码概述
- • Kotlin学习（二）基本类型
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 外部其他进程嵌入到qt FindWindow获得窗口句柄 报错无法链接的外部符号 [email protected] 无法被([email protected]@[email protected]@@引用
- 2. UVa 11524 - InCircle
- 3. The Monocycle（bfs）
- 4. VEC-C滑窗
- 5. 堆排序的应用-TOPK问题
- 6. 实例演示ElasticSearch索引查询term,match,match_phase,query_string之间的区别
- 7. 数学基础知识 集合
- 8. amazeUI 复择框问题解决
- 9. 背包问题理解
- 10. 算数平均-几何平均不等式的证明,从麦克劳林到柯西
- 1. JDK1.8源码(七)——java.util.HashMap 类
- 2. JDK1.8源码(七)——java.util.HashMap 类，java面试题，java基础笔试题，BAT
- 3. JDK1.8源码(九)——java.util.LinkedHashMap 类
- 4. JDK1.8源码(八)——java.util.HashSet 类
- 5. JDK1.8源码(三)——java.lang.String 类
- 6. JDK1.8源码(四)——java.util.Arrays 类
- 7. JDK1.8源码(五)——java.util.ArrayList 类
- 8. JDK1.8源码(六)——java.util.LinkedList 类
- 9. JDK1.8源码(二)——java.lang.Integer 类
- 10. JDK1.8源码(十)——java.util.LinkedHashSet类