HashMap详解
1.HashMap的使用:
(1) 插入键值对数据
public V put(K key, V value)
(2)根据键值获取键值对值数据
public V get(Object key)
(3)获取Map中键值对的个数
public int size()
(4)判断Map集合中是否包含键为key的键值对
public boolean containsKey(Object key)
(5)判断Map集合中是否包含值为value的键值对
boolean containsValue(Object value)
(6)判断Map集合中是否没有任何键值对
public boolean isEmpty()
(7)清空Map集合中所有的键值对
public void clear()
(8)根据键值删除Map中键值对
public V remove(Object key)
public static void main(String[] args) {
// 声明HashMap对象
Map<String,Integer> map= new HashMap<>();
//添加数据
map.put("ZhangYi",98);
map.put("WangEr",99);
map.put("ZhangShan",89);
map.put("Lisi",92);
//根据键值对键值获取数据‘’
int value=map.get("Lisi");
System.out.println("kay:Lisi And value:"+value);
//获取Map中键值对的个数
int size=map.size();
System.out.println("map 中的键值对个数为:"+size);
//判断Map集合中是否包含键为key的键值对
boolean b1=map.containsKey("LiSI");
boolean b2=map.containsKey("Lisi");
System.out.println("是否包含键值为LiSI的键值对数据:"+b1);
System.out.println("是否包含键值为Lisi的键值对数据:"+b2);
//判断Map集合中是否包含值为value的键值对
boolean b3=map.containsValue(99);
boolean b4=map.containsValue(100);
System.out.println("是否包含值为99的键值对数据:"+b3);
System.out.println("是否包含值为100的键值对数据:"+b4);
//判断Map集合中是否没有任何键值对
boolean b5=map.isEmpty();
System.out.println("map中键值对数据是否为空:"+b5);
//根据键值删除Map中键值对
int value2=map.remove("Lisi");
System.out.println("删除了键为Lisi的键值对数据,其值为:"+value2);
boolean b6=map.containsKey("Lisi");
System.out.println("是否包含键值为Lisi的键值对数据:"+b6);
//清空Map集合中所有的键值对
map.clear();
boolean b7=map.isEmpty();
System.out.println("map中键值对数据是否为空:"+b7);
}
}
运行结果:
kay:Lisi And value:92
map 中的键值对个数为:4
是否包含键值为LiSI的键值对数据:false
是否包含键值为Lisi的键值对数据:true
是否包含值为99的键值对数据:true
是否包含值为100的键值对数据:false
map中键值对数据是否为空:false
删除了键为Lisi的键值对数据,其值为:92
是否包含键值为Lisi的键值对数据:false
map中键值对数据是否为空:true
2.HashMap迭代器的使用:
HashMap遍历方式:
1)Key的遍历:
HashMap<Integer,String> map= new HashMap<>();
//添加数据
map.put(12,"ZhangYi");
map.put(23,"WangEr");
map.put(14,"ZhangShan");
map.put(45,"Lisi");
for(Integer key:map.keySet()){
System.out.print("key:"+ key);
System.out.print("value:" +map.get(key));
}
2)value的遍历:
HashMap<Integer,String> map= new HashMap<>();
//添加数据
map.put(12,"ZhangYi");
map.put(23,"WangEr");
map.put(14,"ZhangShan");
map.put(45,"Lisi");
for(String str: map.values()){
//map中的key不可以重复,但是value可以重复
System.out.print("value: " +str);
}
3)Entry的遍历:
HashMap<Integer,String> map= new HashMap<>();
//添加数据
map.put(12,"ZhangYi");
map.put(23,"WangEr");
map.put(14,"ZhangShan");
map.put(45,"Lisi");
//entrySet得到当前HashMap中节点的集合
for(Map.Entry<Integer,String> entry: map.entrySet()){
System.out.println("key: " +entry.getKey()+"value: "+entry.getValue());
}
4)Interator遍历:
HashMap<Integer,String> map= new HashMap<>();
//添加数据
map.put(12,"ZhangYi");
map.put(23,"WangEr");
map.put(14,"ZhangShan");
map.put(45,"Lisi");
Iterator<Map.Entry<Integer,String>> itr = map.entrySet().iterator();
while(itr.hasNext()){
Map.Entry<Integer,String> entry = itr.next();
System.out.println("key: "+entry.getKey()+"value: "+entry.getValue());
}
3.HashMap的底层源码实现:
3.1.HashMap中put()方法:
public V put(K key, V value) {
/**四个参数,第一个hash值,第四个参数表示如果该key存在值,如果为null的话,则插入新的value,最后一个参数,在hashMap中没有用,可以不用管,使用默认的即可**/
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//tab 哈希数组,p 该哈希桶的首节点,n hashMap的长度,i 计算出的数组下标
Node<K,V>[] tab; Node<K,V> p; int n, i;
//获取长度并进行扩容,使用的是懒加载,table一开始是没有加载的,等put后才开始加载
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/**如果计算出的该哈希桶的位置没有值,则把新插入的key-value放到此处,此处就算没有插入成功,也就是发生哈希冲突时也会把哈希桶的首节点赋予p**/
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//发生哈希冲突的几种情况
else {
// e 临时节点的作用, k 存放该当前节点的key
Node<K,V> e; K k;
//第一种,插入的key-value的hash值,key都与当前节点的相等,e = p,则表示为首节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//第二种,hash值不等于首节点,判断该p是否属于红黑树的节点
else if (p instanceof TreeNode)
/**为红黑树的节点,则在红黑树中进行添加,如果该节点已经存在,则返回该节点(不为null),该值很重要,用来判断put操作是否成功,如果添加成功返回null**/
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//第三种,hash值不等于首节点,不为红黑树的节点,则为链表的节点
else {
//遍历该链表
for (int binCount = 0; ; ++binCount) {
//如果找到尾部,则表明添加的key-value没有重复,在尾部进行添加
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//判断是否要转换为红黑树结构
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
//如果链表中有重复的key,e则为当前重复的节点,结束循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//有重复的key,则用待插入值进行覆盖,返回旧值。
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//到了此步骤,则表明待插入的key-value是没有key的重复,因为插入成功e节点的值为null
//修改次数+1
++modCount;
//实际长度+1,判断是否大于临界值,大于则扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
//添加成功
return null;
}
3.2.HashMap之resize()方法
当插入数据时哈希表过于拥挤,即size>threshold 或者table == null时,会触发一次resize扩容操作。扩容时,我们的内部数组扩容了2倍,所以对于每一个插槽内的元素在 rehash时存在两种可能:
1.依然映射到当前下标插槽处
2.映射到高位下标处(当前下标 + 扩容前内部数组长度大小)
final Node<K,V>[] resize() {
//oldTab指向hash桶数组
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//如果oldCap不为空,即hash桶数组不为空
if (oldCap > 0) {
//判断oldCap是否大于最大容量,如果大于最大容量了,就赋值为整数的最大值
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
//直接返回
return oldTab;
}
//如果当前hash桶数组的长度在扩容后仍然小于最大容量,这里扩容指的是以2倍的方式扩容,并且oldCap大于默认值16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//双倍扩容阀值
newThr = oldThr << 1; // double threshold
}
//反之,oldCap小于等于0,但是oldThr大于0
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//oldCap小于等于0,oldThr小于等于0
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
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"})
//新建hash数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//使得旧数组的引用指向新数组
table = newTab;
//进行扩容操作,即复制节点对象到新的hash桶数组中
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//如果旧数组在j位置不为空,将该节点赋值给e
if ((e = oldTab[j]) != null) {
//将旧数组中j位置设置为空,方便gc
oldTab[j] = null;
//如果e后面没有节点
if (e.next == null)
//直接对e的hash值按位与新数组的长度得到index位置,将e节点放置该位置
newTab[e.hash & (newCap - 1)] = e;
//如果e为红黑树的节点类型,那么添加到红黑树中
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//反之e为链表的节点类型,并且e.next != null
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
//将当前节点的next赋值给next引用
next = e.next;
//如果节点e的hash值与原hash桶数组的长度按位与为0
//若与原容量按位与,结果为0,表示将这个节点放入新数组中,位置不变
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//如果节点e的hash值与原hash桶数组的长度按位与不为0
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//如果loTail不为空
if (loTail != null) {
//将loTail.next设置为空
loTail.next = null;
//将loHead赋值给新的hash桶数组j位置
newTab[j] = loHead;
}
//如果hiTail不为空
if (hiTail != null) {
//将hiTail.next设置为空
hiTail.next = null;
//将hiHead赋值给新的hash桶数组[j+旧hash桶数组的长度]
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
3.3.HashMap之get(Object key)方法
public V get(Object key) {
Node<K,V> e;
//getNode得到该key所对应的节点e,节点为null则返回null,反之返回e.value
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;
//判断当前table(桶)不能为空,即桶中存在节点,并且当前key-》index不为空,即该位置存在节点
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//判断该位置的第一个节点(first),如果first.hash等于该key所对应的散列码,first.key等于该key,则直接返回first
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//判断当前first.next后是否存在其他节点,如果存在即first.next != null
if ((e = first.next) != null) {
//判断该first节点是否是红黑树节点,如果是,则调用红黑树中getTreeNode方法
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//do-while循环特点是先执行循环体,再判断条件是否满足
//e为当前节点,如果e.hash等于key所对应的散列码,e.key等于该key,则直接返回e
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
3.4.HashMap之remove(Object key)方法
public V remove(Object key) {
Node<K,V> e;
//remove删除该key所对应的节点e,节点为null则返回null,反之返回e.value
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;
//判断当前table(桶)不能为空,即桶中存在节点,并且当前key-》index不为空,即该位置存在节点
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;
//p为该位置的第一个节点,如果p.hash等于该key所对应的散列码,p.key等于该key,则p为目标节点,赋值给node引用
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
//判断当前p.next后是否存在其他节点,如果存在即p.next != null
else if ((e = p.next) != null) {
//判断该p节点是否是红黑树节点,如果是,则调用红黑树中getTreeNode方法得到该节点,赋值给node引用
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
//反之为链表节点,在该链表中查找到该节点,赋值给node引用
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)))) {
//判断该node节点是否是红黑树节点,如果是则调用红黑树中的removeTreeNode方法
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果node == p, 说明目标删除节点为第一个节点
else if (node == p)
tab[index] = node.next;
//反之,p为目标删除节点的前一个节点,node为目标删除节点,p.next = node.next
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
4.HashMap迭代器实现:
abstract class HashIterator {
//要返回的下一个节点
Node<K,V> next; // next entry to return
//当前节点
Node<K,V> current; // current entry
//期望的结构性修改次数
int expectedModCount; // for fast-fail
//索引位置
int index; // current slot
//HashIterator构造器
HashIterator() {
//期望的结构性修改次数赋值
expectedModCount = modCount;
//当前HashMap中table赋值给t
Node<K,V>[] t = table;
current = next = null;
index = 0;
//查找当前哈希表中第一个非空的数据节点赋值给next
if (t != null && size > 0) { // advance to first entry
do {} while (index < t.length && (next = t[index++]) == null);
}
}
//判断当前迭代器是否含有下一个可迭代的元素
public final boolean hasNext() {
return next != null;
}
//返回当前可迭代器的下一个元素
final Node<K,V> nextNode() {
Node<K,V>[] t;
//next保存当前可迭代的下一个元素,将next赋值给e
Node<K,V> e = next;
//不相等,说明在迭代器迭代的过程中HashMap结构发生变化,则抛出异常
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
//当前下一个可迭代元素不为空并且table也不为空
if ((next = (current = e).next) == null && (t = table) != null) {
//查找当前哈希表中下一个非空的数据节点赋值给next
do {} while (index < t.length && (next = t[index++]) == null);
}
//返回结果
return e;
}
public final void remove() {
//current节点为上一次next返回的节点
Node<K,V> p = current;
if (p == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
//调用HashMap中removeNode(hash, key, value, mathchValue, movable)删除当前key所在节点;
removeNode(hash(key), key, null, false, false);
//更新expectedModCount为最新值
expectedModCount = modCount;
}
}