Java基础——HashMap存储原理简单介绍put与get方法

最新推荐文章于 2025-04-30 11:16:20 发布

原创最新推荐文章于 2025-04-30 11:16:20 发布 · 661 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#HashMap

Java基础专栏收录该内容

17 篇文章

订阅专栏

本文介绍了Java 1.8中HashMap的存储结构，它基于Hash表，结合了数组和链表（或红黑树）的优势。在put操作中，通过计算key的hash值确定插入位置，如果冲突则形成链表或转化为红黑树。get方法通过hash值快速定位到相应节点，遍历链表或红黑树查找匹配项。HashMap内部类Node包含hash、key、value和next字段，用于存储和链接节点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

HashMap的继承关系

在Java1.8版本中，HashMap继承了AbstractMap抽象类并实现了Map接口。

HashMap的存储原理

HashMap底层是Hash表，由数组、单向链表和红黑树构成，该数组为Node类型、数组中每一个元素对应一条单向链表，当一条单向链表的长度>=8时该链表转变为红黑树结构。ArrayList底层为数组的list集合，查找速度快而删除与修改效率低；LinkedList底层为双向链表的list集合，查找效率低，删除与修改效率高；而HashMap底层为Hash表，集合了数组与链表的优点，使得无论查找还是修改删除操作，都有不错的效率。

HashMap中定义了一个内部类Node<K，V>节点继承了Map.Entry<K,V>，该节点中有四个存储空间，分别是hash、key、value、next。

类型	变量名
final int	hash	保存的是根据key计算出的hash值
final K	key	键
V	value	值
Node<K，V>	next	保存的是下一个节点的内存地址

put方法：

1.调用HashMap的put方法时，根据key计算出hash值，并调用putVal方法。

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

2.判断tab数组，如果为null或者长度为0，初始化tab，tab的长度初始值为16。

Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
     n = (tab = resize()).length;

3.根据hash值与hash桶(tab)长度计算出下标i，并根据下标找到对应的Node（tab[i]），如果为null则新创建一个Node存入到该位置(tab[i])。

if ((p = tab[i = (n - 1) & hash]) == null)
   tab[i] = newNode(hash, key, value, null);

4.如果tab[i]存在

4.1如果tab[i]的hash与新hash相等且tab[i]的key与新的key相等，则将该节点的value替换为新的value，并将原value值返回。

Node<K,V> e; K k;
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
    e = p;


if (e != null) { // existing mapping for key
    V oldValue = e.value;
    if (!onlyIfAbsent || oldValue == null)
        e.value = value;
        afterNodeAccess(e);
        return oldValue;
}

4.2如果tab[i]属于TreeNode则调用putTreeVal方法。这一条涉及到扩容问题，当tab[i]对应的单向链表长度超过8，则会转换成红黑树结构。

4.3其他情况下，遍历tab[i]对应的单向链表，如果该节点的hash与key都与新值相等，则跳出循环，该节点的value将被覆盖；如果hash与value不等则进行下一轮的比较；如果tab[i]或是链表中最后一个节点的next为null，则创建一个新节点存放在该节点后面，当单向链表长度大于等于8时，转变为红黑树结构。

//遍历tab[i]对应的单向链表
for (int binCount = 0; ; ++binCount) {

    //如果tab[i]或是链表最后一个位置的next为null，则创建一个新的节点，保存到当前节点的后边。
    if ((e = p.next) == null) {
       p.next = newNode(hash, key, value, null);
       //TREEIFY_THRESHOLD的值为8，这里在tab[i]之后如果单向链表长度>=7，则转换为树形结构
       if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
          treeifyBin(tab, hash);
       break;
    }
    
    //如果hash与key都与新的值相等，跳出循环遍历
    if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
       break;
    
    //如果hash与key的比较不成功，将e所指向的地址指向p，进行下一轮的比较
    p = e;
}

//将原value进行覆盖，并返回原value值。
if (e != null) { // existing mapping for key
   V oldValue = e.value;
   if (!onlyIfAbsent || oldValue == null)
      e.value = value;
      afterNodeAccess(e);
      return oldValue;
}

get方法

1.调用HashMap的put方法时，根据key计算出hash值，并调用getNode方法进行三元表达式判断，返回相应的value值。

public V get(Object key) {
   Node<K,V> e;
   return (e = getNode(hash(key), key)) == null ? null : e.value;
}

2.判断tab是否为null，tab的长度是否为0，tab[i]对应的节点是否为null，如果为null则直接返回null；否则遍历该单向链表使每个节点的hash与value值对新值进行比较，如果相等则返回该节点，如果遍历所有节点都不相符，则返回null，其中如果节点属于TreeNode，则调用getTreeNode方法。

 final Node<K,V> getNode(int hash, Object key) {
      Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    
      //判断tab是否为null，长度是否为0，tab[i]是否为null
      if ((tab = table) != null && (n = tab.length) > 0 && 
        (first = tab[(n - 1) & hash]) != null) {
         
        //如果tab[i]的hash与key与新值相等则返回该节点
        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 while循环对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;
}