前言
今天，我将通过源码分析HashMap 1.8 ，从而讲解HashMap 1.8 相对于 HashMap 1.7 的更新内容，希望你们会喜欢。
示意图.png
1. 简介
类定义
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
主要简介
示意图.png
HashMap 的实现在 JDK 1.7 和 JDK 1.8 差别较大
今天，我将对照 JDK 1.7的源码，在此基础上讲解 JDK 1.8 中 HashMap 的源码解析
2. 数据结构：引入了 红黑树
2.1 主要介绍
示意图
关于 红黑树 的简介
示意图
更加具体的了解，请：点击阅读文章
2.2 存储流程
为了让大家有个感性的认识，只是简单的画出存储流程，更加详细 & 具体的存储流程会在下面源码分析中给出
示意图
2.3 数组元素 & 链表节点的 实现类
HashMap中的数组元素 & 链表节点 采用 Node类 实现
与 JDK 1.7 的对比（Entry类），仅仅只是换了名字
该类的源码分析如下
/**
* Node = HashMap的内部类，实现了Map.Entry接口，本质是 = 一个映射(键值对)
* 实现了getKey()、getValue()、equals(Object o)和hashCode()等方法
**/
static class Node<K,V> implements Map.Entry<K,V> { final int hash; // 哈希值，HashMap根据该值确定记录的位置
final K key; // key
V value; // value
Node<K,V> next;// 链表下一个节点
// 构造方法
Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = 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 V setValue(V newValue) {
V oldValue = value;
value = newValue; return oldValue;
} /**
* hashCode（）
*/
public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value);
} /**
* equals（）
* 作用：判断2个Entry是否相等，必须key和value都相等，才返回true
*/
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;
}
}2.4 红黑树节点 实现类
HashMap中的红黑树节点 采用 TreeNode 类 实现
/**
* 红黑树节点 实现类：继承自LinkedHashMap.Entry<K,V>类
*/
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
// 属性 = 父节点、左子树、右子树、删除辅助节点 + 颜色
TreeNode<K,V> parent;
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev;
boolean red;
// 构造函数
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
// 返回当前节点的根节点
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}3. 具体使用
3.1 主要使用API（方法、函数）
V get(Object key); // 获得指定键的值V put(K key, V value); // 添加键值对void putAll(Map<? extends K, ? extends V> m); // 将指定Map中的键值对 复制到 此Map中V remove(Object key); // 删除该键值对boolean containsKey(Object key); // 判断是否存在该键的键值对；是 则返回trueboolean containsValue(Object value); // 判断是否存在该值的键值对；是 则返回true Set<K> keySet(); // 单独抽取key序列，将所有key生成一个SetCollection<V> values(); // 单独value序列，将所有value生成一个Collectionvoid clear(); // 清除哈希表中的所有键值对int size(); // 返回哈希表中所有 键值对的数量 = 数组中的键值对 + 链表中的键值对boolean isEmpty(); // 判断HashMap是否为空；size == 0时 表示为 空
3.2 使用流程
在具体使用时，主要流程是：
声明1个 HashMap的对象
向 HashMap 添加数据（成对 放入 键 - 值对）
获取 HashMap 的某个数据
获取 HashMap 的全部数据：遍历HashMap
示例代码
import java.util.Collection;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;
public class HashMapTest {
public static void main(String[] args) { /**
* 1. 声明1个 HashMap的对象
*/
Map<String, Integer> map = new HashMap<String, Integer>(); /**
* 2. 向HashMap添加数据（成对 放入 键 - 值对）
*/
map.put("Android", 1);
map.put("Java", 2);
map.put("iOS", 3);
map.put("数据挖掘", 4);
map.put("产品经理", 5); /**
* 3. 获取 HashMap 的某个数据
*/
System.out.println("key = 产品经理时的值为：" + map.get("产品经理")); /**
* 4. 获取 HashMap 的全部数据：遍历HashMap
* 核心思想：
* 步骤1：获得key-value对（Entry） 或 key 或 value的Set集合
* 步骤2：遍历上述Set集合(使用for循环 、 迭代器（Iterator）均可)
* 方法共有3种：分别针对 key-value对（Entry） 或 key 或 value
*/
// 方法1：获得key-value的Set集合 再遍历
System.out.println("方法1"); // 1. 获得key-value对（Entry）的Set集合
Set<Map.Entry<String, Integer>> entrySet = map.entrySet(); // 2. 遍历Set集合，从而获取key-value
// 2.1 通过for循环
for(Map.Entry<String, Integer> entry : entrySet){
System.out.print(entry.getKey());
System.out.println(entry.getValue());
}
System.out.println("----------"); // 2.2 通过迭代器：先获得key-value对（Entry）的Iterator，再循环遍历
Iterator iter1 = entrySet.iterator(); while (iter1.hasNext()) { // 遍历时，需先获取entry，再分别获取key、value
Map.Entry entry = (Map.Entry) iter1.next();
System.out.print((String) entry.getKey());
System.out.println((Integer) entry.getValue());
} // 方法2：获得key的Set集合 再遍历
System.out.println("方法2"); // 1. 获得key的Set集合
Set<String> keySet = map.keySet(); // 2. 遍历Set集合，从而获取key，再获取value
// 2.1 通过for循环
for(String key : keySet){
System.out.print(key);
System.out.println(map.get(key));
}
System.out.println("----------"); // 2.2 通过迭代器：先获得key的Iterator，再循环遍历
Iterator iter2 = keySet.iterator(); String key = null; while (iter2.hasNext()) {
key = (String)iter2.next();
System.out.print(key);
System.out.println(map.get(key));
} // 方法3：获得value的Set集合 再遍历
System.out.println("方法3"); // 1. 获得value的Set集合
Collection valueSet = map.values(); // 2. 遍历Set集合，从而获取value
// 2.1 获得values 的Iterator
Iterator iter3 = valueSet.iterator(); // 2.2 通过遍历，直接获取value
while (iter3.hasNext()) {
System.out.println(iter3.next());
}
}
}// 注：对于遍历方式，推荐使用针对 key-value对（Entry）的方式：效率高// 原因：
// 1. 对于 遍历keySet 、valueSet，实质上 = 遍历了2次：1 = 转为 iterator 迭代器遍历、2 = 从 HashMap 中取出 key 的 value 操作（通过 key 值 hashCode 和 equals 索引）
// 2. 对于 遍历 entrySet ，实质 = 遍历了1次 = 获取存储实体Entry（存储了key 和 value ）运行结果
方法1 Java2 iOS3 数据挖掘4 Android1 产品经理5 ---------- Java2 iOS3 数据挖掘4 Android1 产品经理5 方法2 Java2 iOS3 数据挖掘4 Android1 产品经理5 ---------- Java2 iOS3 数据挖掘4 Android1 产品经理5 方法3 2 3 4 1 5
下面，我们按照上述的使用过程，对一个个步骤进行源码解析
4. 基础知识：HashMap中的重要参数（变量）
在进行真正的源码分析前，先讲解HashMap中的重要参数（变量）
HashMap中的主要参数 同 JDK 1.7 ，即：容量、加载因子、扩容阈值
但由于数据结构中引入了 红黑树，故加入了 与红黑树相关的参数。具体介绍如下：
此处 再次详细说明 加载因子(同 JDK 1.7，但由于其重要性，故此处再次说明)
示意图
总结 数据结构 & 参数方面与 JDK 1.7的区别
示意图.jpg
5. 源码分析
本次的源码分析主要是根据 使用步骤 进行相关函数的详细分析
主要分析内容如下：
下面，我将对每个步骤内容的主要方法进行详细分析
步骤1：声明1个 HashMap的对象
此处主要分析的构造函数 类似 JDK 1.7
/**
* 函数使用原型
*/
Map<String,Integer> map = new HashMap<String,Integer>(); /**
* 源码分析：主要是HashMap的构造函数 = 4个
* 仅贴出关于HashMap构造函数的源码
*/public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable{
// 省略上节阐述的参数
/**
* 构造函数1：默认构造函数（无参）
* 加载因子 & 容量 = 默认 = 0.75、16
*/
public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR;
} /**
* 构造函数2：指定“容量大小”的构造函数
* 加载因子 = 默认 = 0.75 、容量 = 指定大小
*/
public HashMap(int initialCapacity) { // 实际上是调用指定“容量大小”和“加载因子”的构造函数
// 只是在传入的加载因子参数 = 默认加载因子
this(initialCapacity, DEFAULT_LOAD_FACTOR);
} /**
* 构造函数3：指定“容量大小”和“加载因子”的构造函数
* 加载因子 & 容量 = 自己指定
*/
public HashMap(int initialCapacity, float loadFactor) { // 指定初始容量必须非负，否则报错
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// HashMap的最大容量只能是MAXIMUM_CAPACITY，哪怕传入的 > 最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY; // 填充比必须为正
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// 设置 加载因子
this.loadFactor = loadFactor; // 设置 扩容阈值
// 注：此处不是真正的阈值，仅仅只是将传入的容量大小转化为：>传入容量大小的最小的2的幂，该阈值后面会重新计算
// 下面会详细讲解 ->> 分析1
this.threshold = tableSizeFor(initialCapacity);
} /**
* 构造函数4：包含“子Map”的构造函数
* 即 构造出来的HashMap包含传入Map的映射关系
* 加载因子 & 容量 = 默认
*/
public HashMap(Map<? extends K, ? extends V> m) { // 设置容量大小 & 加载因子 = 默认
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 将传入的子Map中的全部元素逐个添加到HashMap中
putMapEntries(m, false);
}
} /**
* 分析1：tableSizeFor(initialCapacity)
* 作用：将传入的容量大小转化为：>传入容量大小的最小的2的幂
* 与JDK 1.7对比：类似于JDK 1.7 中 inflateTable()里的 roundUpToPowerOf2(toSize)
*/
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;
}注：（同JDK 1.7类似）
此处仅用于接收初始容量大小（capacity）、加载因子(Load factor)，但仍无真正初始化哈希表，即初始化存储数组table
此处先给出结论：真正初始化哈希表（初始化存储数组table）是在第1次添加键值对时，即第1次调用put（）时。下面会详细说明
至此，关于HashMap的构造函数讲解完毕。
步骤2：向HashMap添加数据（成对 放入 键 - 值对）
在该步骤中，与JDK 1.7的差别较大：
示意图.png
添加数据的流程如下
注：为了让大家有个感性的认识，只是简单的画出存储流程，更加详细 & 具体的存储流程会在下面源码分析中给出
示意图.png
源码分析
/**
* 函数使用原型
*/
map.put("Android", 1); map.put("Java", 2); map.put("iOS", 3); map.put("数据挖掘", 4); map.put("产品经理", 5); /**
* 源码分析：主要分析HashMap的put函数
*/
public V put(K key, V value) { // 1. 对传入数组的键Key计算Hash值 ->>分析1
// 2. 再调用putVal（）添加数据进去 ->>分析2
return putVal(hash(key), key, value, false, true);
}下面，将详细讲解 上面的2个主要分析点
分析1：hash（key）
/**
* 分析1：hash(key)
* 作用：计算传入数据的哈希码（哈希值、Hash值）
* 该函数在JDK 1.7 和 1.8 中的实现不同，但原理一样 = 扰动函数 = 使得根据key生成的哈希码（hash值）分布更加均匀、更具备随机性，避免出现hash值冲突（即指不同key但生成同1个hash值）
* JDK 1.7 做了9次扰动处理 = 4次位运算 + 5次异或运算
* JDK 1.8 简化了扰动函数 = 只做了2次扰动 = 1次位运算 + 1次异或运算
*/
// JDK 1.7实现：将 键key 转换成 哈希码（hash值）操作 = 使用hashCode() + 4次位运算 + 5次异或运算（9次扰动）
static final int hash(int h) {
h ^= k.hashCode();
h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4);
} // JDK 1.8实现：将 键key 转换成 哈希码（hash值）操作 = 使用hashCode() + 1次位运算 + 1次异或运算（2次扰动）
// 1. 取hashCode值： h = key.hashCode()
// 2. 高位参与低位的运算：h ^ (h >>> 16)
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); // a. 当key = null时，hash值 = 0，所以HashMap的key 可为null
// 注：对比HashTable，HashTable对key直接hashCode（），若key为null时，会抛出异常，所以HashTable的key不可为null
// b. 当key ≠ null时，则通过先计算出 key的 hashCode()（记为h），然后 对哈希码进行 扰动处理： 按位 异或（^） 哈希码自身右移16位后的二进制
} /**
* 计算存储位置的函数分析：indexFor(hash, table.length)
* 注：该函数仅存在于JDK 1.7 ，JDK 1.8中实际上无该函数（直接用1条语句判断写出），但原理相同
* 为了方便讲解，故提前到此讲解
*/
static int indexFor(int h, int length) {
return h & (length-1);
// 将对哈希码扰动处理后的结果 与运算(&) （数组长度-1），最终得到存储在数组table的位置（即数组下标、索引）
}总结 计算存放在数组 table 中的位置（即数组下标、索引）的过程
此处与 JDK 1.7的区别在于：hash值的求解过程中 哈希码的二次处理方式（扰动处理）
步骤1、2 = hash值的求解过程
作者：Sophia_dd35
链接：https://www.jianshu.com/p/8cbd941a89a7
随时随地看视频
