简介
在Java中,Map接口是一个非常重要的接口,它定义了将键映射到值的关系。Map接口位于java.util包中,并提供了一种将键(key)映射到值(value)的方式。键和值可以是任何对象,并且每个键在Map中必须是唯一的。
Map接口的主要实现类包括HashMap、LinkedHashMap、TreeMap等。
Map接口定义了一些重要的方法,包括:
- put(K key, V value): 将指定的值与此映射中的指定键相关联(可选操作)。
- get(Object key): 返回映射中与此键关联的值;如果映射不包含此键的映射关系,则返回null。
- remove(Object key): 如果此映射包含指定键的映射关系,则将其删除。
- containsKey(Object key): 如果此映射包含指定键的映射关系,则返回true。
- containsValue(Object value): 如果此映射将一个或多个键映射到指定值,则返回true。
- putAll(Map<? extends K, ? extends V> m): 将指定映射中的所有映射关系复制到此映射中(可选操作)。
- clear(): 从此映射中移除所有映射关系(可选操作)。
- keySet(): 返回此映射中包含的键的Set视图。
- values(): 返回此映射中包含的值的Collection视图。
- entrySet(): 返回此映射中包含的映射关系的Set视图。
扩容方式
JDK1.7版本扩容
①:先生成新数组;
②:遍历老数组中的每个位置上的链表上的每个元素;
③:获取每个元素的key,并基于新数组长度,计算出每个元素在新数组中的下标;
④:将元素添加到新数组中去;
⑤:所有元素转移完之后,将新数组赋值给HashMap对象的table属性。
JDK1.8版本扩容
①:先生成新数组;
②:遍历老数组中的每个位置上的链表或红黑树;
③:如果是链表,则直接将链表中的每个元素重新计算下标,并添加到新数组中去;
④:如果是红黑树,则先遍历红黑树,先计算出红黑树中每个元素对应在新数组中的下标位置;
a:统计每个下标位置的元素个数;
b:如果该位置下的元素个数超过了8,则生成一个新的红黑树,并将根节点添加到新数组的对应位置;
c:如果该位置下的元素个数没有超过8,那么则生成一个链表,并将链表的头节点添加到新数组的对应位置;
⑤:所有元素转移完了之后,将新数组赋值给HashMap对象的table属性。
源码
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
//默认初始化容量16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;
//扩容因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//连表转化为红黑树数组中元素的个数临界值
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
//连表转化为红黑树数组某一节点连表元素个数的临界值
static final int MIN_TREEIFY_CAPACITY = 64;
}
putVal()方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//临时定义的数组 保存table中的数据
HashMap.Node<K,V>[] tab;
//临时定义变量,根据hash值,接受数组中这个下标位置上的数据
HashMap.Node<K,V> p;
int n, i;
//jdk1.8 使用默认构造函数时,第一调用put方法时,初始化table数组,使用默认值
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//之后再次添加分为下面两种情况
//第一种就是在table数组的(n - 1) & hash下标下没有数据,则直接将该value放入到数组下标位置
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//第二种情况 在table数组的(n - 1) & hash下标下已经存在数据
HashMap.Node<K,V> e;
K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//数组下标中的数据和想要加入的数据一样
else if (p instanceof HashMap.TreeNode)
//判断要加入的数据类型是TreeNode类型,则走putTreeVal方法
e = ((HashMap.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);//如果是null 则直接将数据放到该位置
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;
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;
}
resize()方法
final HashMap.Node<K, V>[] resize() {
HashMap.Node<K, V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//数组已经初始化了
if (oldCap > 0) {
//如果数组容量大于等于最大容量 则不进行如何处理,直接返回
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//如果在0到最大范围之间,则扩容两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//数组初始化
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else {
// 这是使用默认值的情况,使用无参构造函数
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"})
HashMap.Node<K, V>[] newTab = (HashMap.Node<K, V>[]) new HashMap.Node[newCap];
//将扩容后的哈希表赋值给table
table = newTab;
//如果旧表不为空,即存在数据
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
HashMap.Node<K, V> e;
if ((e = oldTab[j]) != null) {
//将节点设置为空
oldTab[j] = null;
if (e.next == null)
//如果链表只有一个节点,将旧表节点重新计算放入新表
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof HashMap.TreeNode)
//如果该节点是红黑树,执行split方法来处理红黑树节点,包括升级、降级、回退到链表等操作
((HashMap.TreeNode<K, V>) e).split(this, newTab, j, oldCap);
else { // preserve order
//此时桶中结构为链表,且大于1个节点,开始遍历链表
HashMap.Node<K, V> loHead = null, loTail = null;
HashMap.Node<K, V> hiHead = null, hiTail = null;
HashMap.Node<K, V> next;
do {
next = e.next;
// 从if-else可以看出,对一条链表进行遍历,将链表中的元素通过
// 条件(e.hash & oldCap) == 0来进行分类,满足条件的存放在loHead链上
// 不满足条件的存放在hiHead链上,且都是尾部插入方式,这和JDK7的头部插入有区别
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);
//将loHead链放在数组的原位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//将hiHead链放在数组的(j + oldCap)位置
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
treeifyBin()方法
final void treeifyBin(Node<K,V>[] tab, int hash) {
//定义几个变量,n是数组长度,index是索引
int n, index; Node<K,V> e;
//这里的tab指的是本HashMap中的数组,n为数字长度,如果数组为null或者数组长度小于64
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
//则调用resize()方法直接扩容,不转红黑树
resize();
//否则说明满足转红黑树条件,通过按位与运算取得索引index,并将该索引对应的node节点赋值给e,e不为null时
else if ((e = tab[index = (n - 1) & hash]) != null) {
//定义几个变量,hd代表头节点,tl代表尾节点
TreeNode<K,V> hd = null, tl = null;
do {
//先把e节点转成TreeNode类型,并赋值给p
TreeNode<K,V> p = replacementTreeNode(e, null);
//如果尾节点tl为空,则说明还没有根节点,试想下,这时元素数目都超过8个了,还能没有尾节点么,所以没有尾节点只能说明还没设置根节点
if (tl == null)
//设置根节点,把p赋值给根节点hd
hd = p;
else {
//把tl设置为p的前驱节点
p.prev = tl;
//把p设置为tl的后继节点,这两步其实就是我指向你,你指向我的关系,为了形成双向链表
tl.next = p;
}
//把首节点设置成p后,把p赋值给尾节点tl,然后会再取链表的下一个节点,转成TreeNode类型后再赋值给p,如此循环
tl = p;
//取下一个节点,直到下一个节点为空,也就代表这链表遍历好了
} while ((e = e.next) != null);
//用新生成的双向链表替代旧的单向链表,其实就是把这个数组对应的位置重新赋值成新双向链表的首节点
if ((tab[index] = hd) != null)
//这个方法里就开始做各种比较,左旋右旋,然后把双向链表搞成一个红黑树
hd.treeify(tab);
}
}
getNode()方法
final HashMap.Node<K, V> getNode(int hash, Object key) {
//临时变量储存table数组
HashMap.Node[] tab;
//临时变量获取第一个元素
HashMap.Node first;
//n为table的长度
int n;
//如果table已经被初始化切table数组的长度大于0,在已知元素的查找位置上有元素则进入if判断
//否则返回null,即没有找到元素
if ((tab = this.table) != null && (n = tab.length) > 0 && (first = tab[n - 1 & hash]) != null) {
Object k;
//first元素存在,切first元素即锁需要查找的元素,直接返回first.
if (first.hash == hash && ((k = first.key) == key || key != null && key.equals(k))) {
return first;
}
//e为临时变量储存在first元素不是所需元素的下一个元素
HashMap.Node e;
if ((e = first.next) != null) {
//当链表被树化后的查询
if (first instanceof HashMap.TreeNode) {
return ((HashMap.TreeNode)first).getTreeNode(hash, key);
}
//如果链表没有被树化,则使用链表的方式查询.
do {
//循环判断当前的临时变量e是否与所需元素相同
//相同则返回e元素,不相同则返回null
if (e.hash == hash && ((k = e.key) == key || key != null && key.equals(k))) {
return e;
}
} while((e = e.next) != null);
}
}
return null;
}
removeNode()方法
final HashMap.Node<K, V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) {
//获取临时变量tab存储table数组
HashMap.Node[] tab;
HashMap.Node p;
int n;
int index;
//获取n为table长度,index为hash后的位置
//如果当前table已经初始化,且index位置上的元素不为空,则进入if判断,准备查找需要删除的元素
if ((tab = this.table) != null && (n = tab.length) > 0 && (p = tab[index = n - 1 & hash]) != null) {
HashMap.Node<K, V> node = null;
Object k;
//如果当前index位置上第一个元素则是需要被删除的元素,则将node指定为p,开始删除
//如果不是则进入else循环开始查找
if (p.hash == hash && ((k = p.key) == key || key != null && key.equals(k))) {
node = p;
} else {
HashMap.Node e;
//如果当前index位置上下一个元素不为空,则判断类型进行查找
if ((e = p.next) != null) {
//如果index位置为红黑树,则调用树的查找
if (p instanceof HashMap.TreeNode) {
node = ((HashMap.TreeNode)p).getTreeNode(hash, key);
} else {
//如果当前index位置为链表,则循环向后查找
label88: {
while(e.hash != hash || (k = e.key) != key && (key == null || !key.equals(k))) {
p = e;
if ((e = e.next) == null) {
break label88;
}
}
//将node指定为e,不论e是否为null.
node = e;
}
}
}
}
//如果node不为null,则代表查找到key值对应的元素
Object v;
if (node != null && (!matchValue || (v = ((HashMap.Node)node).value) == value || value != null && value.equals(v))) {
//如果被查找到的node类型为树类型,则调用树的删除方法
if (node instanceof HashMap.TreeNode) {
((HashMap.TreeNode)node).removeTreeNode(this, tab, movable);
}
//如果node==p,则代表是index当前位置的第一个元素被查找到,直接将index位置的元素后移即可.
else if (node == p) {
tab[index] = ((HashMap.Node)node).next;
}
//如果不是第一个元素,则将查找到元素的前一个元素的next指针指向被查找到的元素的next元素,即可实现删除
else {
p.next = ((HashMap.Node)node).next;
}
//将操作数加一
++this.modCount;
//将map中元素个数减一
--this.size;
this.afterNodeRemoval((HashMap.Node)node);
//返回被删除的元素
return (HashMap.Node)node;
}
}
return null;
}
computeIfAbsent()方法
//指定 key,找到对应的Node节点,执行remappingFunction.apply(key),返回新的 value 值,会执行以下四种情况:
//Node 不为 null 且 Node.value 不为null,返回 Node.value
//value 为 null,直接返回 null
//value 不为null,Node不为null 且 Node.value为null,设置 Node.value为value,返回 value
//value 不为null,Node为null,新建节点 (key, v), 返回 value
@Override
public V computeIfAbsent(K key,
Function<? super K, ? extends V> mappingFunction) {
/* null 异常检测 */
if (mappingFunction == null)
throw new NullPointerException();
/* 计算 key 的 hash 值 */
int hash = hash(key);
Node<K,V>[] tab; Node<K,V> first; int n, i;
int binCount = 0;
TreeNode<K,V> t = null;
Node<K,V> old = null;
/* 元素个数 > 临界值 || tab 为空 || tab 长度为 0 */
if (size > threshold || (tab = table) == null ||
(n = tab.length) == 0)
/* 进行扩容并获得 扩容后的数组长度 */
n = (tab = resize()).length;
/* 拿到 key 值对应的桶位下标,并获取首元素的节点 */
if ((first = tab[i = (n - 1) & hash]) != null) {
/* first 若属于树节点,使用树节点的查找Node节点方法getTreeNode() */
if (first instanceof TreeNode)
old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
else {
/* 链表查找 node 节点 */
Node<K,V> e = first; K k;
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
old = e;
break;
}
++binCount;
} while ((e = e.next) != null);
}
/* old 不为 null && old.value 不为 null,返回旧值oldValue */
V oldValue;
if (old != null && (oldValue = old.value) != null) {
/* 预留函数 */
afterNodeAccess(old);
return oldValue;
}
}
/* 执行指定的操作 */
V v = mappingFunction.apply(key);
/* v 为 null 直接 return null */
if (v == null) {
return null;
} else if (old != null) { // old 不为null,但old.value 为 null
/* 设置旧值为 v */
old.value = v;
/* 预留函数 */
afterNodeAccess(old);
return v;
}
/* t != null 即 当前桶位的元素为树节点,添加新值(key, v) */
else if (t != null)
t.putTreeVal(this, tab, hash, key, v);
else {
/* 添加链节点(key,v) */
tab[i] = newNode(hash, key, v, first);
/* 判断 binCount >= 8 - 1,是否需要转化树节点 */
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
}
/* 更新 modCount,size */
++modCount;
++size;
/* 预留函数 */
afterNodeInsertion(true);
return v;
}
computeIfPresent()方法
public V computeIfPresent(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
/* null 异常检测 */
if (remappingFunction == null)
throw new NullPointerException();
Node<K,V> e; V oldValue;
/* 计算 key 的 hash 值 */
int hash = hash(key);
/* e 不为空 && e.value 不为空 */
if ((e = getNode(hash, key)) != null &&
(oldValue = e.value) != null) {
/* 执行指定动作 返回v */
V v = remappingFunction.apply(key, oldValue);
/* v != null 则替换该 value 值 */
if (v != null) {
e.value = v;
/* 预留函数 */
afterNodeAccess(e);
return v;
}
else
/* v 为null 则删除 key 对应的节点 */
removeNode(hash, key, null, false, true);
}
/* 找不到 key 对应的节点 或者 Node.value 为空,直接返回 null */
return null;
}
示例
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
// 创建一个HashMap实例
Map<String, Integer> map = new HashMap<>();
// 向map中添加键值对
map.put("one", 1);
map.put("two", 2);
map.put("three", 3);
// 获取并打印map中的值
System.out.println("Value for 'one': " + map.get("one"));
// 检查map中是否包含某个键
System.out.println("Contains key 'two'? " + map.containsKey("two"));
// 遍历map的键
for (String key : map.keySet()) {
System.out.println("Key: " + key + ", Value: " + map.get(key));
}
// 遍历map的键值对
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
// 移除一个键值对
map.remove("two");
System.out.println("Map after removal: " + map);
// 清空map
map.clear();
System.out.println("Map after clearing: " + map);
}
}
在这个示例中,我们创建了一个HashMap实例,并添加了一些键值对。然后,我们演示了如何获取值、检查键的存在、遍历键和键值对,以及如何移除和清空Map。
Map接口及其实现类在Java中广泛应用于各种场景,如缓存、数据库查询结果的存储、配置管理等。它们提供了一种高效、灵活的方式来处理键值对关系。