HashMap 数据结构
Java 1.7 HashMap 的数据结构是 数组 + 链表
Java 1.8 HashMap 的数据结构是 数组 + 链表 + 红黑树
HashMap 重点参数
这里是针对1.8总结的。
HashMap的默认初始化容量, 必须是二次幂
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大容量,由带参数的任何一个构造函数执行。 必须是二次幂<= 1<<30。
static final int MAXIMUM_CAPACITY = 1 << 30;
//负载系数,容量*负载系数=负载因子、加载因子,当实际使用容量达到负载因子时进行扩容。
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 红黑树的阈值 链表长度 >= 8 将会转成一个红黑树
static final int TREEIFY_THRESHOLD = 8;
// 拆分树时的阈值 红黑树的节点<=6的时候将会转为链表结构
static final int UNTREEIFY_THRESHOLD = 6;
// 红黑树最小容量
static final int MIN_TREEIFY_CAPACITY = 64;
HashMap 的链表是单项还是双向的
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V 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;
}
HashMap 的构造方法
构造方法一共是4种
无参构造:HashMap() ,设置了一个默认负载因子
有参构造:HashMap(int initialCapacity, float loadFactor) ,initialCapacity是初始容量,loadFactor负载因子
有参构造:HashMap(int initialCapacity) ,initialCapacity是初始容量
有参构造: HashMap(Map<? extends K, ? extends V> m) ,m是Map参数
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and load factor.
* @param initialCapacity the initial capacity
* @param loadFactor the load factor
* @throws IllegalArgumentException if the initial capacity is negative
* or the load factor is nonpositive
*/
//自定义初始大小和负载系数
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;
this.threshold = tableSizeFor(initialCapacity);
}
//自定义初始大小
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//默认设定
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//带参数构造
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);//添加参数
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
//
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize();
//循环添加
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
HashMap 的GET()方法
这个hash(key)方法是一个关键方法。它返回一个int值,这个值决定了Node<key , value>节点的位置。
我们都知道HashMap的数据结构,数组+链表然后根据情况决定是否转为红黑树(这个后面讲),数组的每一个下标可以看成一个桶!那么这个桶是什么呢,就是 Node<>[],就是Node的数组表示。我们来看一下node是个啥?
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V 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 int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = 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;
}
}
看代码我们知道,Node是一个内部类,它有4个参数 hash key value next。这里也有一个hash,这个hash 的值就来源于key.hashCode().
下面是get的源码
重点是getNode()方法,找下标的这个算法。也就是第一个if的最后一个条件。
用文字来解析下这个代码
一共是5个if
第一个 if:map不是空的,map指定的下标也不能是空的
第二个 if: first节点的hash于key(get(key)是这个key)的hash码相等,并且 key于first.key特相等 ,那么放回first
第三个 if:是判断first是否有下一个节点
第四个 if:是判断 first是不是树类型,如果是就执行return ((TreeNode<K,V>)first).getTreeNode(hash, key);
如果不是那就循环链表,逐一比较key hash的值。相同返回节点数据。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
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) {
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;
}
((TreeNode<K,V>)first).getTreeNode(hash, key);如果是红黑树,那是怎样从树种找到这个key 的呢??
方法的源码贴上一起来看看。
没有什么特别的吧。一串if else 就是取左节点还是右节点。
//root()这个方法就是个parent 赋值了一下,重点是find(h,k,null)方法!
final TreeNode<K,V> getTreeNode(int h, Object k) {
return ((parent != null) ? root() : this).find(h, k, null);
}
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
if ((ph = p.hash) > h) // 大于 h ,取左
p = pl;
else if (ph < h) // 小于 h ,取右
p = pr;
else if ((pk = p.key) == k || (k != null && k.equals(pk))) // 相同返回
return p;
else if (pl == null) // 为空 取反
p = pr;
else if (pr == null) // 为空取反
p = pl;
else if ((kc != null || //比较类型和可比性取元素
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
else if ((q = pr.find(h, k, kc)) != null) // 迭代先找右边
return q;
else
p = pl;
} while (p != null);
return null;
}
HashMap 的put(k,v)方法.
第一步当前的map是否创建/为空。
第二步存储的位置是否为空, 为空直接存 (位置的计算方法下面说哦)
第三步存储的位置不为空
3.1 位置hash 和 参数hash相同 切key相同,传入的值和以保存的值相等(hash+key)不操作
3.2 存到为红黑树
3.3 存到链表,循环找到下一个空闲的位置,并逐步将参数值与已存在的值进行比较(hash+key)
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;
//第一步当前的map是否创建/为空。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; ---为空的话九创键一下
//第二步存储的位置是否为空, 为空直接存
if ((p = tab[i = (n - 1) & hash]) == null) --- 第一个元素为空时
tab[i] = newNode(hash, key, value, null); --- node内部类的构造方法返回一个node
else {
//############################## 重点哦 #############################################
// 第三步存储的位置不为空
Node<K,V> e; K k;
//1位置hash 和 参数hash相同 切key相同,传入的值和以保存的值相等(hash+key)不操作
//key值 或者 hash值是相同的直接替换,value会覆盖之前的value值。
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//2存到为红黑树
//
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//3存到链表
//
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;
}
// 链表下一个位置的值 于 参数值相同 不做操作
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// e = p.next , p=e, e = p.next 迭代
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;
}
############################红黑树存储######################################
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 = -1;
else if (ph < h) // 右
dir = 1;
else if ((pk = p.key) == k || (k != null && k.equals(pk))) //已存在直接放回
return p;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) { // 插找已经存在节点上是否存在key 存在直接返回
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;
if ((p = (dir <= 0) ? p.left : p.right) == null) { // dir <=0 存在左节点 反之存在右节点
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;
}
}
}
put(K,V)方法 存储位置算法
node在数组中的下标位置。
结果 < 数组大小 , 范围是0 - (数组大小 - 1)
数 % 数组大小 = [0 - (数组大小 - 1)]
数使用的就是 key.hashCode(); 但是源码中使用的方法和这个方法不一样
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
(n -1) & hash
n 是数组大小 , hash是key的hash值。使用的是 & 运算符。回忆一下 & 运算符是怎么一个算法来着???
同为1 结果为1 , 否则结果为 0;
(16 - 1 ) & 3373707
111 转10进制是 7. 最大值是01111 也是15.
根据计算啊 数%数组大小 结果范围是 [ 数组大小 - 1 ]
根据计算啊 (n -1) & hash 结果范围也是 [ 数组大小 - 1 ]
所以计算方式不同,但结果没差别。之所一直这样写,是因为最终执行代码的是机器!二进制计算更快。
上面的做法虽然完成了任务,但是由于关键点在hash值得最后4位(这个是根据扩容而不断增加的),怎样保证结果能更为均散吗?
要想做到最后位的不相同,可以拆分为 高16位 ,和低16位 ,然后高低做一个异或运算
高16位 1100011001110001
低16位 1001110000000111 ^ 回忆一下^运算: 同0为0 不同为1
——————————————————————
1101111001110111
看一下源码:
嗯…反正就是打乱了一下
static final int hash(Object key) {
int h;
//这里是hash ^ hash>>>16 (高16位) 这样一个结果
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
上面保证了,hash是分散的, op2如果为01110呢, 因为是 & 运算,都为1结果才为1, op2的最后一位是0,那结果肯定为0,这样就有加大重复的可能性,这是怎么办呢???
那就保证 op2 的结果一定为:0111111,0后面都为1.
**op2 = (n -1) , n = 000000001; 00000001 - 1 = 01111111; **
那么 n 必须为2次幂。
源码解决方法:
//如果你在构造参数中传入的数,不是2的N次幂,咋办?
//下面的源码方法帮我们解决这个问题。
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 扩容
先想想 “扩容”这个动作需要几步来完成???
- 第一步 既然要扩容,那必定是需要一个新的大的容器
- 第二步 新的容器有了,那就旧容器的数据拿过来。
- 第二步 之 1情况 下标中只有一个元素
- 第二步 之 2情况 下标中是一个链表数据
- 第二步 之 3情况 下标中是一个红黑树数据
第一步:扩容新数组源码:
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length; //16
int oldThr = threshold; // 12
int newCap, newThr = 0;
if (oldCap > 0) { //扩容会进入这个if中执行
// oldCap >= 1<< 30
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// (oldCap << 1 = 32)< (1 << 30)
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
// 32 >= 16
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 12 << 1 = 24
newThr = oldThr << 1; // double threshold
}
// oldCap ===》 32 10000<<1 = 100000
// newThr ===》 24 1100<<1 = 11000
第二步:移动数据到新的数组中
扩容完成后: resize操作,老数组移动到新数组中
源码展示:
if (oldTab != null) {//数组不为空
for (int j = 0; j < oldCap; ++j) {//开始遍历
Node<K,V> e;
if ((e = oldTab[j]) != null) {//下标不为空
oldTab[j] = null;
if (e.next == null)//如果e没有下一个元素 只有一个元素
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;
//##############
/* $运算 都为1 结果为1 否则为0
结果为0 与 不为0
关键在于hash倒数第5位是否为0
已知 oldCap是16 二进制是10000
所以 hsah倒数第5位为0 结果为0 ,倒数第5位为1结果为1
11000110011100011001110000000111 e.hash
10000 & oldCap &
--------------------------------------------------
与e.hash & (newCap - 1)这样的效果一样吗?
是一样的
结论:
hsah倒数第5位是0,结果为0 成立,这时result和原来【扩容前】的结果一样 原来的位置保持不变
hash倒数第5位是1,结果不为0,这时和原来的结果倒数第5位多了一个1,也就是多了一个16,原来的位置+16(oldCap)
依次列推:16 32 64...
*/
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
key.hashcode & (n-1) 这是put时是这样的算法
e.hash & (newCap - 1) 扩容后旧数组移动到新数组中时是这样的算法
key.hash & 15 e.hash & 31 hash值是一样的 第二个参数不一样 救过是不会变的哦。