HashMap

原创已于 2024-04-10 15:22:47 修改 · 置顶 · 706 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#哈希算法 #散列表 #算法

于 2019-02-25 18:02:56 首次发布

java基础专栏收录该内容

28 篇文章

订阅专栏

本文详细解析了HashMap的工作原理，包括其内部结构、扩容机制、解决哈希冲突的方法以及时间复杂度分析。同时，对比了HashMap与Hashtable的区别，并介绍了ConcurrentHashMap的相关特性。

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

ofeqx.com 方程式科技共享平台外文资料好找好用。大数据有序化,
专业垂直领域体系的知识共享盘平台，发表您的创作与我们共产知识。

hashmap为什么在发生hash冲突后把元素放在链表的头部？

最后放入的数据被再次访问的几率更大，所有叫他优先被访问。

0.75的由来

泊松分布 Poisson

hash 取值为啥异或

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

通过异或运算能够是的计算出来的hash比较均匀，不容易出现冲突。

hash冲突指的什么如何解决？

HashMap使用key的hashCode来寻找存储位置，不同的key可能具有相同的hashCode，这时候就出现哈希冲突了，也叫做哈希碰撞，为了解决哈希冲突，HashMap的实现上选取了链地址方法，也就是将哈希值一样的entry保存在同一个数组项里面，可以把一个数组项当做一个桶，桶里面装的entry的key的hashCode是一样的。

(n - 1) & hash 计算出数组角标的位置
解决就是在角标上链表
链表长度大于8 且数组长度大于64 变成红黑树

存放链表过程

    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
        数组没链表 直接新增
        数组角标有元素
        判断2个对象是不是相等 先hash 后 equals
           if (p.hash == hash &&  ((k = p.key) == key || (key != null && key.equals(k))))

相等话链表元素直接覆盖
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;

不相等的话
新增链表且放到链表元素的第一位（放在现在链表元素第一个的最左边）

取链表数据

        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;

取链表的第一个数据
且取key 唯一的key的元素

JDK 1.7
hashmap 是数组 + 链表数据结构
hashmap 是一个entry对象的数组数组中的每一个entry元素又是一个链表的头节点
jdk1.7 结构图如下：
在这里插入图片描述
JDK 1.8结构图如下：

在这里插入图片描述

HashMap

初始化容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 2的4次方 16
最大扩容容量
static final int MAXIMUM_CAPACITY = 1 << 30;// 2的30次方最大
容量因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;

默认初始化容量 16 ，因子 0.75，元素12个就会rehash扩容一倍

当HashMap中元素个数大于16 * 0.75=12的时候，就把数组的大小扩展为 2*16=32，即扩大一倍
为什么选择0.75 的原因？
负载因子loadFactor衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费

时间复杂度 0（1）链表 0（n） jdk1.8 阈值 0（lgn）
所以jdk1.7 hashmap 时间复杂度为 0(1) ~ 0(n)
jdk1.8 hashmap 时间复杂度为 0(1) ~ 0(lgn)

put方法

在这里插入图片描述

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        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);
        else {
            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 TreeNode)
                e = ((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);
                        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;
    }

put 过程：
1.如果当前 map 中无数据，执行 resize 方法；
2.如果要插入的键值对要存放的这个位置刚好没有元素，那么把他封装成
Node 对象，并放在这个位置上；
3.如果发生碰撞，判断 node 的类型是红黑树还是链表；
3.1.如果为红黑树，则将 K-V 对插在红黑树对应的位置
3.2.如果为链表，遍历链表（有三个 if 判断）
a.如果为链表最后一个 node，则将新的 node 节点插入到链表尾；
b.插入完后，如果链表的 node 数量大于 8，则将链表转为红黑树的操
作；如果当前哈希表为空或数组长度小于 64，会扩容；否则转化为红黑树。
转化的过程：先遍历链表，将链表的节点转化为红黑树的节点；然后
将链表转化为红黑树。
c.遍历链表时，如果 key 已存在，则直接 break 循环。
4.判断是否要扩容；
5.返回。

get方法

在这里插入图片描述

    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;
    }

get 过程：
1．对 key 的 hashCode()做 hash，然后再计算 index；如果 bucket 里的第一个
节点直接命中则返回；
2.如果有冲突，则通过 key.equals(k)去查找对应的 entry。
若为树，则在树中通过 key.equals(k)查找。
若为链表，则在链表中通过 key.equals(k)查找。
计算数值

如何确定 key 在数组的位置？

public class Test1 {

 public static void main(String[] args) {
      
      String a = "q";
               
      int hash = hash(a.hashCode());
      
      Object indexFor = indexFor(hash, 32);
      System.out.println(indexFor);
 
      }
 static int indexFor(int h, int length) {
         return h & (length-1);
     }
 
static int hash(int h) { 
    h ^= (h >>> 20) ^ (h >>> 12); 
    return h ^ (h >>> 7) ^ (h >>> 4); 
}

总结：
key 进行hashcode
进行hash 算法
进行indexFor 方法得到数组角标的位置

HashMap 中 key 和 value 都允许为 null。
键值对永远都放在以table[0]为头结点的链表中。
链表每次都是放到头部位置。
第一个元素放到链表的头位置，第二个也是放到链表的头位置。
当我们往HashMap中put元素的时候，先根据key的hashCode重新计算hash值，根据hash值得到这个元素在数组中的位置（即下标），如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。

jdk1.8
HashMap是数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的
resize 超过容量因子就会数组增加1倍