HashMap
HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
1.HashMap的数据结构
（1）JDK 8 之前
将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可
（2）JDK 8 之后
相比于之前的版本，jdk1.8在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。
====================JDK8 HashMap底层结构=============================
// HashMap中的Node数组
transient Node<K,V>[] table;
// HashMap中的静态内部类Node节点，组成单向链表
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
// 省略部分代码
}
// HashMap中的TreeNode节点，构成树模型
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
// 省略部分代码
}
JDK1.7 VS JDK1.8 比较
JDK1.8主要解决或优化了一下问题：
- resize 扩容优化
- 引入了红黑树，目的是避免单条链表过长而影响查询效率，红黑树算法请参考
- 解决了多线程死循环问题，但仍是非线程安全的，多线程时可能会造成数据丢失问题。
| 不同 | JDK 1.7 | JDK 1.8 |
|---|---|---|
| 存储结构 | 数组 + 链表 | 数组 + 链表 + 红黑树 |
| 初始化方式 | 单独函数：inflateTable() | 直接集成到了扩容函数resize()中 |
| hash值计算方式 | 扰动处理 = 9次扰动 = 4次位运算 + 5次异或运算 | 扰动处理 = 2次扰动 = 1次位运算 + 1次异或运算 |
| 存放数据的规则 | 无冲突时，存放数组；冲突时，存放链表 | 无冲突时，存放数组；冲突 & 链表长度 < 8：存放单链表；冲突 & 链表长度 > 8：树化并存放红黑树 |
| 插入数据方式 | 头插法（先讲原位置的数据移到后1位，再插入数据到该位置） | 尾插法（直接插入到链表尾部/红黑树） |
| 扩容后存储位置的计算方式 | 全部按照原来方法进行计算（即hashCode ->> 扰动函数 ->> (h&length-1)） | 按照扩容后的规律计算（即扩容后的位置=原位置 or 原位置 + 旧容量） |
2.底层原理
- 当我们往Hashmap中put元素时，利用key的hashCode重新hash计算出当前对象的元素在数组中的下标
- 存储时，如果出现hash值相同的key，此时有两种情况。(1)如果key相同，则覆盖原始值；(2)如果key不同（出现冲突），则将当前的key-value放入链表中
- 获取时，直接找到hash值对应的下标，在进一步判断key是否相同，从而找到对应值。
- 理解了以上过程就不难明白HashMap是如何解决hash冲突的问题，核心就是使用了数组的存储方式，然后将冲突的key的对象放入链表中，一旦发现冲突就在链表中做进一步的对比。
（1）HashMap 各常量、成员变量作用
//创建 HashMap 时未指定初始容量情况下的默认容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//HashMap 的最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//HashMap 默认的装载因子,当 HashMap 中元素数量超过 容量*装载因子 时，进行 resize() 操作
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//用来确定何时将解决 hash 冲突的链表转变为红黑树
static final int TREEIFY_THRESHOLD = 8;
// 用来确定何时将解决 hash 冲突的红黑树转变为链表
static final int UNTREEIFY_THRESHOLD = 6;
/* 当需要将解决 hash 冲突的链表转变为红黑树时，需要判断下此时数组容量，若是由于数组容量太小（小于 MIN_TREEIFY_CAPACITY ）导致的 hash 冲突太多，则不进行链表转变为红黑树操作，转为利用 resize() 函数对 hashMap 扩容 */
static final int MIN_TREEIFY_CAPACITY = 64;
//保存Node<K,V>节点的数组
transient Node<K,V>[] table;
//由 hashMap 中 Node<K,V> 节点构成的 set
transient Set<Map.Entry<K,V>> entrySet;
//记录 hashMap 当前存储的元素的数量
transient int size;
//记录 hashMap 发生结构性变化的次数（注意 value 的覆盖不属于结构性变化）
transient int modCount;
//threshold的值应等于 table.length * loadFactor, size 超过这个值时进行 resize()扩容
int threshold;
//记录 hashMap 装载因子
final float loadFactor;
（2）HashMap的构造器
====================空参构造器============================
public HashMap() {
// 所有参数均采用默认值，threshold=0
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
====================带参构造器============================
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
====================带参构造器============================
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;
//注意此种方法创建的 hashMap 初始容量的值存在 threshold 中
this.threshold = tableSizeFor(initialCapacity);
}
// 该方法方法返回的值是最接近 initialCapacity 的2的幂作为threshold
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;
}
（3）先从put说起
不同于JDK 8 之前，HashMap在实例化的时候并没有在底层初始化map，只有在第一次put元素时，才会在底层初始化一个容量为16的map
当我们put的时候，首先计算 key的hash值，这里调用了 hash方法，hash方法实际是让key.hashCode()与key.hashCode()>>>16进行异或操作，高16bit补0，一个数和0异或不变，所以 hash 函数大概的作用就是：高16bit不变，低16bit和高16bit做了一个异或，目的是减少碰撞。按照函数注释，因为bucket数组大小是2的幂，计算下标index = (table.length - 1) & hash，如果不做 hash 处理，相当于散列生效的只有几个低 bit 位，为了减少散列的碰撞，设计者综合考虑了速度、作用、质量之后，使用高16bit和低16bit异或来简单处理减少碰撞，而且JDK8中用了复杂度 O（logn）的树结构来提升碰撞下的性能。
流程图
源码分析
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
===============================================================
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 1.判断是否数组是否为空
if ((tab = table) == null || (n = tab.length) == 0)
// 首次添加，初始化tab为容量为16的map成功，n=16
n = (tab = resize()).length;
// 2.计算index，判断数组的该位置是否为null
//(n - 1) & hash 确定元素存放在哪个桶中，桶为空，新生成结点放入桶中(此时，这个结点是放在数组中)
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 3.数组的该index处已经有元素
else {
Node<K,V> e; K k;
// 3.1 只有一个结点
// p就是该index上的node结点，比较其hash值是否与待添加的node结点的hash相同
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 将第一个元素赋值给e，用e来记录
e = p;
// 3.2 存在树结构
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 3.3 存在链表结构
else {
for (int binCount = 0; ; ++binCount) {
// 3.3.1 是否到达链表尾部
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 链表长度是否超过规定的阈值8
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 当tab.length >=64(MIN_TREEIFY_CAPACITY)时，才转换为树结构
// 否则进行对数组进行扩容
treeifyBin(tab, hash);
break;
}
// 3.3.2 判断链表中的每个结点是否与待插入结点相同
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 后移
p = e;
}
}
//判断当前的key已经存在的情况下，再来一个相同的hash值、key值时，返回之前的value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 记录 hashMap 发生结构性变化的次数（注意 value 的覆盖不属于结构性变化）
++modCount;
// 实际大小大于阈值则扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
-
判断键值对数组table[i]是否为空或为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，如果超过，进行扩容。
（4）再说resize
在putval()中，我们曾调用过两次resize()方法
在初始化时会对其进行扩容
当该数组的size大于其threshold值（第一次为12），而在JDK 7 中，扩容之后需要重新去计算其Hash值，根据Hash值对其进行分发；在JDK 8 中，扩容的同时也会伴随的原数组上面的元素进行重新分配。具体是根据在数组的某个结点的位置中进行判断（e.hash & oldCap）是否为0，重新进行hash分配后，该元素的位置要么停留在原始位置，要么移动到原始位置+增加的数组大小这个位置上
注意点：
-
在JDK 8 中，resize方法是在hashmap中的键值对大于阀值时或者初始化时，就调用resize方法进行扩容；
-
每次扩展的时候，都是扩展2倍；
-
扩展后Node对象的位置要么在原位置，要么移动到原偏移量两倍的位置。
源码分析
=================当数组的size超过阈值时=================
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
// oldCap : 默认容量为16
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// oldThr：16 * 0.75 = 12
int oldThr = threshold;
int newCap, newThr = 0;
// 1.如果oldCap大于0的话，说明hash桶数组不为空
if (oldCap > 0) {
// 1.1如果大于最大容量了，就赋值为整数最大的阀值
// MAXIMUM_CAPACITY:1073741824
if (oldCap >= MAXIMUM_CAPACITY) {
// MAX_VALUE:2147483647
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 1.2如果当前数组的容量在扩容2倍后仍然小于最大容量 并且oldCap大于默认值16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// threshold扩大为原来的2倍，24
newThr = oldThr << 1; // double threshold
}
// 2.当oldCap为0时，但threshold大于0，代表有参构造有cap传入，threshold已经被初始化成最小2的n次幂
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 3.当用无参构造创建map时，给出默认容量和threshold 16, 16*0.75
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 新的threshold = 新的cap * 0.75
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) {
// 遍历原来的数组
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 1.当该位置的结点为单个结点时(非链表)，重新计算该节点在新数组中的位置，并加入
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 2.当该位置的结点为红黑树结构时，并且e.next!=null，那么处理树中元素的重排
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
// 3.当该位置结点为链表结构时，并且e.next!=null，那么处理链表中元素重排
else { // preserve order
// loHead,loTail 代表扩容后不用变换下标
Node<K,V> loHead = null, loTail = null;
// hiHead,hiTail 代表扩容后变换下标
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
// 初始化head指向链表当前元素e，e不一定是链表的第一个元素，初始化后loHead
// 代表下标保持不变的链表的头元素
loHead = e;
else
// loTail.next指向当前e
loTail.next = e;
// loTail指向当前的元素e
// 初始化后，loTail和loHead指向相同的内存，所以当loTail.next指向下一个元素时，
// 底层数组中的元素的next引用也相应发生变化，造成lowHead.next.next.....
// 跟随loTail同步，使得lowHead可以链接到所有属于该链表的元素。
loTail = e;
}
else {
if (hiTail == null)
// 初始化head指向链表当前元素e, 初始化后hiHead代表下标更改的链表头元素
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 遍历结束, 将tail指向null，并把链表头放入新数组的相应下标，形成新的映射。
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
（5）关于get的分析
实际上是根据输入节点的 hash 值和 key 值利用getNode 方法进行查找
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
=========================getNode()方法====================================
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// tab不为空，且根据hash值计算出的索引位置不为null时
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 判断该索引位置的结点是否为要输入结点
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) {
// 当该结点为树结构时
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;
}
（6）谈谈红黑树
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
TreeNode<K,V> root = (parent != null) ? root() : this;
//从根节点开始查找合适的插入位置（与二叉搜索树查找过程相同）
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
if ((ph = p.hash) > h)
// dir < 0,查找当前结点的左结点
dir = -1;
else if (ph < h)
// dir > 0,查找当前结点的右结点
dir = 1;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
//进入这个else if 代表 hash 值相同，key 相同
return p;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
// 进入这个else if代表：
// 1.当前结点与待插入结点hash相同，key不同
// 2.ｋ是不可比较的，即ｋ并未实现 comparable<K> 接口
if (!searched) {
//在以当前节点为根的整个树上搜索是否存在待插入节点（只会搜索一次）
TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
//若树中存在待插入节点，直接返回
return q;
}
dir = tieBreakOrder(k, pk);
}
TreeNode<K,V> xp = p;
// 找到了待插入的位置，xp 为待插入节点的父节点
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next;
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
3.解决哈希冲突
Hash，一般翻译为“散列”，就是把任意长度的输入通过散列算法，变换成固定长度的输出，该输出就是散列值（哈希值）,简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数
哈希冲突：当两个不同的输入值，根据同一散列函数计算出相同的散列值的现象，我们就把它叫做碰撞（哈希碰撞）
（1）HashMap的数据结构
在Java中，保存数据有两种比较简单的数据结构：数组和链表。数组的特点是：寻址容易，插入和删除困难；链表的特点是：寻址困难，但插入和删除容易；所以我们将数组和链表结合在一起，发挥两者各自的优势，使用一种叫做链地址法的方式可以解决哈希冲突
**链地址法：**将拥有相同哈希值的对象组织成一个链表放在hash值所对应的bucket下
（2）HashMap中的hash()
这比在JDK 1.7中，更为简洁，相比在1.7中的4次位运算，5次异或运算（9次扰动），在1.8中，只进行了1次位运算和1次异或运算（2次扰动）
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); // 与自己右移16位进行异或运算（高低位异或）
}
（3）红黑树
判断链表长度是否大于8，并且数组容量大于64的话把链表转换为红黑树
我们的HashMap中存在大量数据时，加入我们某个bucket下对应的链表有n个元素，那么遍历时间复杂度就为O(n)，为了针对这个问题，JDK1.8在HashMap中新增了红黑树的数据结构，进一步使得遍历复杂度降低至O(logn)；
总结：
1. 使用链地址法（使用散列表）来链接拥有相同hash值的数据；
2. 使用2次扰动函数（hash函数）来降低哈希冲突的概率，使得数据分布更平均；
3. 引入红黑树进一步降低遍历的时间复杂度，使得遍历更快；
4.需要注意的地方
（1）关于HashMap的key
使用任何类都可以作为 Map 的 key，必须重写
hashCode()和equals()方法
-
重写
hashCode()是因为需要计算存储数据的存储位置，需要注意不要试图从散列码计算中排除掉一个对象的关键部分来提高性能，这样虽然能更快但可能会导致更多的Hash碰撞； -
重写
equals()方法，需要遵守自反性、对称性、传递性、一致性以及对于任何非null的引用值x，x.equals(null)必须返回false的这几个特性，目的是为了保证key在哈希表中的唯一性
HashMap中String、Integer这样的包装类最适合作为Key
String、Integer等包装类的特性能够保证Hash值的不可更改性和计算准确性，能够有效的减少Hash碰撞的几率
- 都是final类型，即不可变性，保证key的不可更改性，不会存在获取hash值不同的情况
- 内部已重写了
equals()、hashCode()等方法，遵守了HashMap内部的规范（不清楚可以去上面看看putValue的过程），不容易出现Hash值计算错误的情况
（2）HashMap非线程安全
HashTable线程安全
-
线程安全： HashMap 是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过
synchronized修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！）； -
效率： 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它；
-
对Null key 和Null value的支持： HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。但是在 HashTable 中 put 进的键值只要有一个 null，直接抛NullPointerException。
-
**初始容量大小和每次扩充容量大小的不同 **： ①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。②创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小。也就是说 HashMap 总是使用2的幂作为哈希表的大小。
-
底层数据结构： JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。Hashtable 采用 数组+链表 的形式。
ConcurrentHashMap线程安全
- 底层数据结构： JDK1.7的 ConcurrentHashMap 底层采用 分段的数组+链表 实现，JDK1.8 采用的数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树；
- 实现线程安全的方式：① 在JDK1.7的时候，ConcurrentHashMap（分段锁） 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。（默认分配16个Segment，比Hashtable效率提高16倍。） 到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6以后 对 synchronized锁做了很多优化） 整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本。
==推荐使用：==在 Hashtable 的类注释可以看到，Hashtable 是保留类不建议使用，推荐在单线程环境下使用 HashMap 替代，如果需要多线程使用则用 ConcurrentHashMap 替代。
扫一扫
753
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
