2.HashMap

最新推荐文章于 2024-10-01 23:14:11 发布

Sakura_00001

最新推荐文章于 2024-10-01 23:14:11 发布

阅读量1.1k

点赞数 1

分类专栏： Java集合相关文章标签：哈希算法算法数据结构 hash

本文链接：https://blog.csdn.net/weixin_45783741/article/details/126830940

版权

Java集合相关专栏收录该内容

3 篇文章 0 订阅

订阅专栏

2.HashMap

掌握 HashMap 的基本数据结构
掌握树化
理解索引计算方法、二次 hash 的意义、容量对索引计算的影响
掌握 put 流程、扩容、扩容因子
理解并发使用 HashMap 可能导致的问题
理解 key 的设计
hashTable和hashMap的区别

1）基本数据结构

1.7 数组 + 链表
1.8 数组 + （链表O(n) | 红黑树O(log2为底(n)）链表元素比较多时，转换为红黑树；红黑树元素删除减少，转换为链表：

2）树化与退化

为什么要用红黑树（树化意义）

红黑树用来避免 DoS 攻击，防止链表超长时性能下降，树化应当是偶然情况，是保底策略
hash 表的查找，更新的时间复杂度是 $O(1)$，而红黑树的查找，更新的时间复杂度是 $O(log_2⁡n )$，TreeNode 占用空间也比普通 Node 的大，如非必要，尽量还是使用链表
hash 值如果足够随机，则在 hash 表内按泊松分布，在负载因子 0.75 的情况下，长度超过 8 的链表出现概率是 0.00000006，树化阈值选择 8 就是为了让树化几率足够小

树化规则

当链表长度超过树化阈值 8 时，先尝试扩容来减少链表长度，如果数组容量已经 >=64，才会进行树化

退化规则

情况1：在扩容时如果拆分树时，树元素个数
情况2：remove 树节点时，若 root、root.left、root.right、root.left.left 有一个为 null ，也会退化为链表

3）索引计算

索引计算方法

首先，计算对象的 hashCode()
再进行调用 HashMap 的 hash() 方法进行二次哈希
- 二次 hash() 是为了综合高位数据，让哈希分布更为均匀
最后 hashCode() % capacity(数组长度) 得到索引或 hashCode() & ( capacity(数组长度) – 1 ) 得到索引

例：a: 97 % 16 = 1

b: 98 & (16-1) = 2

数组容量为何是 2 的 n 次幂

计算索引时效率更高：如果是 2 的 n 次幂可以使用位与运算代替取模
扩容时重新计算索引效率更高： hash & oldCap(旧的容量) == 0 的元素留在原来位置，否则新位置 = 旧位置 + oldCap

注意:

二次 hash 是为了配合容量是2的次幂这一设计前提，如果 hash 表的容量不是 2 的 n 次幂，则不必二次 hash
容量是 2 的 n 次幂** 这一设计计算索引效率更好，但 hash 的分散性就不好，需要二次 hash 来作为补偿，没有采用这一设计的典型例子是 Hashtable
hashCode都有了,为何还要提供hash()方法?数组容量为何是2的n次幂? **

① 计算对象的hashCode(), 再进行调用HashMap的hash()方法进行二次哈希，最后& (capacity - 1)得到索引

② 二次hash()是为了综合高位数据，让哈希分布更为均匀

③ 计算索引时，如果是2的n次幂可以使用位与运算代替取模,效率更高;扩容时hash & oldCap == 0的元素留在原来位置，否则新位置=旧位置+ oldCap

④ 但①、②、③都是为了配合容量为2的n次幂时的优化手段,例如Hashtable的容量就不是2的n次幂,并不能说哪种设计更优，应该是设计者综合了各种因素,最终选择了使用2的n次幂作为容量

4）put 与扩容

put 流程

HashMap 是懒惰创建数组的，首次使用才创建数组
计算索引（桶下标）
如果桶下标还没人占用，创建 Node 占位返回
如果桶下标已经有人占用
1. 已经是 TreeNode 走红黑树的添加或更新逻辑
2. 是普通 Node，走链表的添加或更新逻辑，如果链表长度超过树化阈值，走树化逻辑
返回前检查容量是否超过阈值，一旦超过进行扩容（超过数组长度的3/4扩容）

1.7 与 1.8 的区别

链表插入节点时，1.7 是头插法，1.8 是尾插法
1.7 是大于等于阈值且没有空位时才扩容，而 1.8 是大于阈值就扩容
1.8 在扩容计算 Node 索引时，会优化

扩容（加载）因子为何默认是 0.75f

在空间占用与查询时间之间取得较好的权衡
大于这个值，空间节省了，但链表就会比较长影响性能
小于这个值，冲突减少了，但扩容就会更频繁，空间占用也更多

5）多线程操作hashMap会有什么问题? 并发丢失数据问题

5.1扩容死链（1.7 会存在）

e 和 next 都是局部变量，用来指向当前节点和下一个节点

线程1（绿色）的临时变量 e 和 next 刚引用了这俩节点，还未来得及移动节点，发生了线程切换，由线程2（蓝色）完成扩容和迁移

线程2 扩容完成，由于头插法，链表顺序颠倒。但线程1 的临时变量 e 和 next 还引用了这俩节点，还要再来一遍迁移

第一次循环

- 循环接着线程切换前运行，注意此时 e 指向的是节点 a，next 指向的是节点 b
- e 头插 a 节点，注意图中画了两份 a 节点，但事实上只有一个（为了不让箭头特别乱画了两份）
- 当循环结束是 e 会指向 next 也就是 b 节点

第二次循环
- next 指向了节点 a
- e 头插节点 b
- 当循环结束时，e 指向 next 也就是节点 a

第三次循环
- next 指向了 null
- e 头插节点 a，a 的 next 指向了 b（之前 a.next 一直是 null），b 的 next 指向 a，死链已成
- 当循环结束时，e 指向 next 也就是 null，因此第四次循环时会正常退出

5.2 数据错乱（1.7，1.8 都会存在）

7）hashMap允许key为null的原因

hashMap中使用hash()方法来计算key的哈希值，当key为空时，直接另key的哈希值为0，不走key.hashCode()方法；
hashMap虽然支持key和value为null，但是null作为key只能有一个，null作为value可以有多个；
因为hashMap中，如果key值一样，那么会覆盖相同key值的value为最新，所以key为null只能有一个。

6）key 的设计

key 的设计要求

HashMap 的 key 可以为 null，但 Map 的其他实现则不然
作为 key 的对象，必须实现 hashCode 和 equals，并且 key 的内容不能修改（不可变）
key 的 hashCode 应该有良好的散列性

如果 key 可变，例如修改了 age 会导致再次查询时查询不到

public class HashMapMutableKey {
    public static void main(String[] args) {
        HashMap<Student, Object> map = new HashMap<>();
        Student stu = new Student("张三", 18);
        map.put(stu, new Object());

        System.out.println(map.get(stu));

        stu.age = 19;
        System.out.println(map.get(stu));
    }

    static class Student {
        String name;
        int age;

        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return age == student.age && Objects.equals(name, student.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    }
}

String 对象的 hashCode() 设计

目标是达到较为均匀的散列效果，每个字符串的 hashCode 足够独特
字符串中的每个字符都可以表现为一个数字，称为 $S_i$，其中 i 的范围是 0 ~ n - 1
散列公式为： $S_0∗31^{(n-1)}+ S_1∗31^{(n-2)}+ … S_i ∗ 31^{(n-1-i)}+ …S_{(n-1)}∗31^0$
31 代入公式有较好的散列特性，并且 31 * h 可以被优化为
- 即 $32 ∗h -h $
- 即 $2^5 ∗h -h$
- 即 $h≪5 -h$

7）HashTable和HashMap的区别

相同点:

hashMap和HashTable都实现了map、Cloneable（可克隆）、Serializable（可序列化）这三个接口

不同点:

底层数据结构不同:jdk1.7底层都是数组+链表,但jdk1.8 HashMap加入了红黑树
键值不同：Hashtable 是不允许键或值为 null 的，HashMap 的键值则都可以为 null。
添加key-value的hash值算法不同：HashMap添加元素时，是使用自定义的哈希算法,而HashTable是直接采用key的hashCode()
实现方式不同：Hashtable 继承的是 Dictionary类，而 HashMap 继承的是 AbstractMap 类。
初始化容量不同：HashMap 的初始容量为：16，Hashtable 初始容量为：11，两者的负载因子默认都是：0.75。
扩容机制不同：当已用容量>总容量 * 负载因子时，HashMap 扩容规则为当前容量翻倍，Hashtable 扩容规则为当前容量翻倍 +1。
支持的遍历种类不同：HashMap只支持Iterator遍历,而HashTable支持Iterator和Enumeration两种方式遍历
迭代器不同：HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为，要看JVM。而Hashtable则不会。
部分API不同：HashMap不支持contains(Object value)方法，没有重写toString()方法,而HashTable支持contains(Object value)方法，而且重写了toString()方法
同步性不同: Hashtable是同步(synchronized)的，适用于多线程环境, 而hashmap不是同步的，适用于单线程环境。多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。

由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。