Loading

[Java基础]HashMap

HashMap

建议使用不可变对象作为Key，终极目的就是避免hashcode的改变

image

HashMap的数据结构

HashMap是:数组+链表/红黑树（JDK1.8增加了红黑树部分）

数据底层具体存储的是什么？

Node<k,v>

数据结构

// 默认初始容量(数组默认大小):16，2的整数次方
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
 
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
 
// 默认负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//装载因子用来衡量HashMap满的程度，表示当map集合中存储的数据达到当前数组大小的75%则需要进行扩容
 
// 链表转红黑树边界
static final int TREEIFY_THRESHOLD = 8;
 
// 红黑树转离链表边界
static final int UNTREEIFY_THRESHOLD = 6;
 
// 哈希桶数组
transient Node<K,V>[] table;
 
// 实际存储的元素个数
transient int size;
 
// 当map里面的数据大于这个threshold就会进行扩容
// 阈值 = table.length * loadFactor
int threshold

  1. DEFAULT_INITIAL_CAPACITY: 默认初始容量，即哈希表的数组默认大小，被设置为 1 << 4，也就是 2 的 4 次方，即 16。这是因为 HashMap 的数组大小通常是 2 的整数次方，这样有助于在计算哈希索引时更高效。

  2. MAXIMUM_CAPACITY: 最大容量，被设置为 1 << 30，即 2 的 30 次方。这是 HashMap 可以容纳的最大元素数量。

  3. DEFAULT_LOAD_FACTOR: 默认负载因子，被设置为 0.75f。负载因子是一个衡量 HashMap 满的程度的参数，当存储的数据达到数组大小的 75% 时，会触发扩容操作。

  4. TREEIFY_THRESHOLD: 链表转红黑树的阈值，被设置为 8。当哈希桶中的链表长度达到 8 时，链表会被转换成红黑树，以提高查询效率。

  5. UNTREEIFY_THRESHOLD: 红黑树转链表的阈值，被设置为 6。当红黑树中的元素减少到 6 时，红黑树会被转换回链表。

  6. table: 哈希桶数组，用于存储键值对。transient 关键字表示该字段不会被默认的序列化机制序列化。

  7. size: 实际存储的元素个数，即 HashMap 中键值对的数量。

  8. threshold: 扩容阈值，计算方式为 table.length * loadFactor。当实际存储的元素个数大于等于这个阈值时，触发扩容操作。

Node结构

从源码可知，HashMap类中有一个非常重要的字段，就是 Node[] table，即哈希桶数组，明显它是一个Node的数组。

static class Node<K,V> implements Map.Entry<K,V> {

    final int hash;//用来定位数组索引位置
    final K key;
          V value;
    Node<K,V> next;//链表的下一个Node节点
 
    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是HashMap的一个内部类，实现了Map.Entry接口，本质是就是一个映射(键值对)。

HashMap的数据存储

  1. 哈希表来存储
    HashMap采用哈希表来存储数据。哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构，只要输入待查找的值即key，即可查找到其对应的值。哈希表其实就是数组的一种扩展，由数组演化而来。可以说，如果没有数组，就没有散列表。

  2. 哈希函数
    哈希表中元素存储地址是由哈希函数确定的,将数据元素的关键字Key作为自变量，通过一定的函数关系（称为哈希函数），计算出的值，即为该元素的存储地址。表示为：Addr = H（key）,哈希表中哈希函数的设计是相当重要的，这也是建哈希表过程中的关键问题。

  3. 核心问题
    建立一个哈希表之前需要解决两个主要问题：
    1)构造一个合适的哈希函数,均匀性 H（key）的值均匀分布在哈希表中
    2)冲突的处理 在哈希表中，不同的关键字值对应到同一个存储位置的现象。

  4. 哈希冲突：

链式哈希表

哈希表为解决冲突，可以采用地址法和链地址法等来解决问题，Java中HashMap采用了链地址法。链地址法，简单来说，就是数组加链表的结合,如下图所示：
HashMap的哈希函数

    /**
    * 重新计算哈希值
    */
    static final int hash(Object key) {

        int h;    
        // h = key.hashCode() 为第一步 取hashCode值
        // h ^ (h >>> 16) 为第二步 高位参与运算
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

//计算数组槽位
(n - 1) & hash
n-1的二进制实际上是00000001111的形式，
与运算的结果是保留hash的后几位如果n=16就是保留后四位，散列到0-15

对key进行了hashCode运算，得到一个32位的int值h,然后用h 异或 h>>>16位。

在JDK1.8的实现中，优化了高位运算的算法，通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)。

这样做的好处是，可以将hashcode高位和低位的值进行混合做异或运算，而且混合后，低位的信息中加入了高位的信息，这样高位的信息被变相的保留了下来。

等于说计算下标时把hash的高16位也参与进来了，掺杂的元素多了，那么生成的hash值的随机性会增大，减少了hash碰撞。

备注：

^异或：不同为1，相同为0
>>>：无符号右移：右边补0
&运算：两位同时为“1”，结果才为“1，否则为0
h & (table.length -1)来得到该对象的保存位，而HashMap底层数组的长度总是2的n次方。

为什么槽位数必须使用2^n？

1.为了让哈希后的结果更加均匀

假如槽位数不是16，而是17，则槽位计算公式变成：(17 – 1) & hash
从上文可以看出，计算结果将会大大趋同，hashcode参加&运算后被更多位的0屏蔽，计算结果只剩下两种0和16，这对于hashmap来说是一种灾难。

2.等价于length取模

当length总是2的n次方时，h& (length-1)运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。

位运算的运算效率高于算术运算，原因是算术运算还是会被转化为位运算。

最终目的还是为了让哈希后的结果更均匀的分布，减少哈希碰撞，提升hashmap的运行效率。

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;

    // 当前对象的数组是null 或者数组长度时0时，则需要初始化数组
    if ((tab = table) == null || (n = tab.length) == 0) 
    {
        n = (tab = resize()).length;
    }

    // 使用hash与数组长度减一的值进行异或得到分散的数组下标，预示着按照计算现在的
    // key会存放到这个位置上，如果这个位置上没有值，那么直接新建k-v节点存放
    // 其中长度n是一个2的幂次数
    if ((p = tab[i = (n - 1) & hash]) == null) {
        tab[i] = newNode(hash, key, value, null);
    }

    // 如果走到else这一步，说明key索引到的数组位置上已经存在内容，即出现了碰撞
    // 这个时候需要更为复杂处理碰撞的方式来处理，如链表和树
    else 
    {
        Node<K,V> e; K k;

        //节点key存在，直接覆盖value
        if (p.hash == hash &&
        ((k = p.key) == key || (key != null && key.equals(k)))) 
        {
            e = p;
        }
        // 判断该链为红黑树
        else if (p instanceof TreeNode) 
        {
            // 其中this表示当前HashMap, tab为map中的数组
            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);
                    // TREEIFY_THRESHOLD = 8
                    // 从0开始的，如果到了7则说明满8了，这个时候就需要转
                    // 重新确定是否是扩容还是转用红黑树了
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                    treeifyBin(tab, hash);
                    break;
                }
                // 找到了碰撞节点中，key完全相等的节点，则用新节点替换老节点
                if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
            
        // 此时的e是保存的被碰撞的那个节点，即老节点
        if (e != null) 
        { // existing mapping for key
            V oldValue = e.value;
            // onlyIfAbsent是方法的调用参数，表示是否替换已存在的值，
            // 在默认的put方法中这个值是false，所以这里会用新值替换旧值
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            // Callbacks to allow LinkedHashMap post-actions
                afterNodeAccess(e);
            return oldValue;
        }
    }
    // map变更性操作计数器
    // 比如map结构化的变更像内容增减或者rehash，这将直接导致外部map的并发
    // 迭代引起fail-fast问题，该值就是比较的基础
    ++modCount;
 
    // size即map中包括k-v数量的多少
    // 超过最大容量 就扩容
    if (++size > threshold)
        resize();
    // Callbacks to allow LinkedHashMap post-actions
    afterNodeInsertion(evict);
    return null;
}

HashMap的put方法执行过程整体如下：

  • 判断键值对数组table[]是否为空或为null，否则执行resize()进行扩容；

  • 根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加

  • 判断table[i]的首个元素是否和key一样，如果相同直接覆盖value

  • 判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对

  • 遍历table[i]，判断链表长度是否大于等于8，大于等于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；

  • 插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。

  • 先判断桶数组是不是空，

    • 如果是，先扩容
    • 如果不是空，
      • 判断hash位置上有没有元素
        • 如果没有，直接插入
        • 如果有，判断该位上的元素是不是和即将插入的元素有相同的key
          • 如果key相同，直接覆盖value
          • 如果key不同，说明拉了链，或者拉了树
            • 如果拉了树，对树进行插入操作
            • 如果拉了链，遍历这个链，查找链的末尾，或者链上有相同的key，覆盖value，
              • 如果插入后链的长度等于8，转为红黑树。

扩容

HashMap 何时扩容？

HASHMAP中的元素达到负载因子0.75的时候

HashMap总结

HashMap底层结构？基于Map接口的实现，数组+链表的结构，JDK 1.8后加入了红黑树，链表长度>=8（链表序号到达7）变红黑树,<6变链表

两个对象的hashcode相同会发生什么? Hash冲突，HashMap通过链表来解决hash冲突

HashMap 中 equals() 和 hashCode() 有什么作用？ HashMap 的添加、获取时需要通过 key 的 hashCode() 进行 hash()，然后计算下标 ( n-1 & hash)，从而获得要找的同的位置。当发生冲突（碰撞）时，利用 key.equals() 方法去链表或树中去查找对应的节点

hash 的实现,hash = key.hashCode() ^ (key.hashCode() >>> 16)， hashCode 进行无符号右移 16 位，然后进行按位异或，得到这个键的哈希值，由于哈希表的容量都是 2 的 N 次方，在当前，元素的 hashCode() 在很多时候下低位是相同的，这将导致冲突（碰撞），因此 1.8 以后做了个移位操作：将元素的 hashCode() 和自己右移 16 位后的结果求异或

HashMap线程安全吗？HashMap读写效率较高，但是因为其是非同步的，即读写等操作都是没有锁保护的，所以在多线程场景下是不安全的，容易出现数据不一致的问题，在单线程场景下非常推荐使用，HashMap 在多线程环境下不是线程安全的。这是因为 HashMap 的实现是基于哈希表的，而哈希表的操作涉及到多个步骤，包括计算哈希码、定位桶位置、插入或检索元素等。在多线程环境下，多个线程同时对 HashMap 进行修改操作可能导致数据不一致或者丢失。

以下是一些可能导致线程不安全的情况：

  • 竞态条件（Race Condition）： 多个线程同时尝试插入或删除元素时，可能导致竞态条件。两个线程可能同时检测到某个位置为空，然后都尝试插入元素，导致其中一个线程的操作被覆盖。
  • 扩容操作： 当 HashMap 需要扩容时，会创建一个新的数组并将旧的元素重新分配到新数组中。在这个过程中，如果有其他线程同时对 HashMap 进行修改，可能会导致元素在扩容过程中丢失或者被重复添加。

为了在多线程环境下保证线程安全，可以使用 ConcurrentHashMap 类，它提供了一些并发安全的操作。ConcurrentHashMap 使用分段锁的机制，将哈希表分成多个段，每个段上都有一个独立的锁，从而降低了锁的粒度，提高了并发性能。这样，不同的线程可以同时修改不同的段，避免了整个数据结构的锁竞争。

总的来说，如果需要在多线程环境中使用哈希表，推荐使用 ConcurrentHashMap 而不是 HashMap，以确保线程安全性。

如何做到让HashMap线程安全？

在Java中，HashMap本身不是线程安全的，但可以通过以下几种方式来实现线程安全的HashMap：

  • 使用Collections.synchronizedMap方法：
    Map<K, V> synchronizedMap = Collections.synchronizedMap(new HashMap<K, V>());
    这将返回一个线程安全的Map，它在每个方法上都使用同步机制来确保线程安全。但请注意，虽然这确保了每个方法的原子性，但在多个操作之间，仍然可能需要额外的同步。

  • 使用ConcurrentHashMap： ConcurrentHashMap是Java提供的线程安全的Map实现。它使用分段锁机制，每个段相当于一个小的HashMap，不同的段之间互不影响，这样可以提高并发性能。
    Map<K, V> concurrentMap = new ConcurrentHashMap<K, V>();

  • 使用Collections.synchronizedMap包装HashMap的迭代器： 如果你使用Collections.synchronizedMap来创建线程安全的HashMap，当你迭代Map时，仍然需要手动同步。你可以通过在迭代器上使用synchronized块来实现：

Map<K, V> synchronizedMap = Collections.synchronizedMap(new HashMap<K, V>());
Set<K> keySet = synchronizedMap.keySet();
synchronized (keySet) {
    Iterator<K> iterator = keySet.iterator();
    while (iterator.hasNext()) {
        K key = iterator.next();
        // 在此处执行操作
    }
}

如果需要线程安全的HashMap，推荐使用ConcurrentHashMap，因为它在并发场景下性能更好。根据具体的需求，选择适合的方法来保证线程安全。

  • ConcurrentHashMap怎么保证线程安全的？
    ConcurrentHashMap是Java集合框架中的线程安全的Map实现。它采用了一些策略来确保在多线程环境中的安全性：

    • 分段锁（Segmentation）： ConcurrentHashMap将整个数据结构分割成多个独立的段（segments），每个段独立地管理一部分数据。每个段都类似于一个小的HashMap，有自己的锁。这样，不同段的数据可以在不同的锁上进行操作，提高了并发度。当一个线程在一个段上进行操作时，其他线程可以同时在其他段上进行操作，减小了竞争范围。

    • 精细化的锁策略： 在ConcurrentHashMap中，只有在读写冲突的时候才会使用锁，而且只锁定与冲突相关的段，而不是整个Map。这种细粒度的锁策略减小了锁的争用，提高了并发性能。

    • 读操作的无锁支持： ConcurrentHashMap对于读操作提供了无锁支持，允许多个线程同时进行读取操作，不会阻塞。只有在写操作发生时才需要加锁，确保写操作的原子性和可见性。

CAS（Compare and Swap）操作： ConcurrentHashMap使用CAS操作来确保对数据的原子更新。CAS是一种无锁算法，它比传统的锁机制更轻量级。通过CAS，ConcurrentHashMap可以在不加锁的情况下完成一些简单的操作。

适应性自动调整： ConcurrentHashMap在运行时会根据负载因子、并发度等参数进行自动调整。这使得它在不同的负载和并发情况下都能够保持高效。

ConcurrentHashMap通过使用分段锁、细粒度的锁策略、无锁的读操作和CAS操作等技术，以及适应性自动调整，来保证在多线程环境中的高并发性能和线程安全。这些特性使得ConcurrentHashMap成为处理高并发情况下Map操作的理想选择。

HashTable

线程安全，但是效率太低了，synchronized修饰方法，只允许一个线程访问

HashMap 和 TreeMap 的比较

  1. 数据结构方面
    HashMap是基于哈希表+数组来实现的，而TreeMap是基于红黑树实现的。使用HashMap需要键对象明确定义了hashCode()和equals()这两个方法，而且为了优化HashMap空间的使用，可以调整初始容量大小和扩容。TreeMap没有大小设置选项，因为，红黑树结构总是处于平衡状态。

  2. HashMap比TreeMap的性能更高。
    HashMap的时间复杂度是O（1），它是通过哈希函数计算的哈希地址。而TreeMap主要是保证数据平衡，时间复杂度是O（log2 n）。

  3. HashMap和TreeMap都是非线程安全的。
    如果在多线程并发情况下建议使用ConcurrentHashMap；如果既要保证线程安全又要保证顺序，可以使用 Collections.synchronizedMap()方法转化为线程安全的集合。

  4. 应用场景方面
    HashMap是无序的，而TreeMap是有序的。TreeMap适用于按自然顺序或自定义顺序遍历键的场景。HashMap适用于在Map中插入、删除和定位元素。日常开发建议多使用HashMap，只有在需要排序的时候才使用TreeMap。

哈希冲突

开放定址法

使用某种探测算法在散列表中寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到。就是即使key产生hash冲突，也不会形成链表，而是将所有元素都存入哈希表里。发生hash冲突时，就以当前地址为基准，进行再寻址的方法去寻址下一个地址，直到找到一个为空的地址为止。

实现方式有：

  1. 线性探查：发生hash冲突时，顺序查找下一个位置，直到找到一个空位置（固定步长1探测）

  2. 二次探查：在发生hash冲突时，在表的左右位置进行按一定步长跳跃式探测（固定步长n探测）

  3. 伪随机探测：在发生hash冲突时，根据公式生成一个随机数，作为此次探测空位置的步长（随机步长n探测）。

再哈希法

这种方式是同时构造多个哈希函数，当产生冲突时，计算另一个哈希函数的值。这种方法不易产生聚集，但增加了计算时间。

链地址法（拉链法）

jdk1.8 中HashMap，ConcurrentHashMap都是采用这个方法，使用链表来保存发生hash冲突的key，即不同的key有一样的hash值，将这些发生冲突的 value 组成一个单向链表（只有next指针，没有pre指针）

posted @   Duancf  阅读(7)  评论(0)  编辑  收藏  举报
相关博文：
· [Java基础]HashMap
· [Java并发]ConcurrentHashMap
· java集合知识
· 2024新鲜出炉 Java集合常见面试题总结(下)
· 一文彻底弄懂ConcurrentHashMap，轻松应对面试官！
阅读排行：
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
点击右上角即可分享
微信分享提示