JDK1.8中的HashMap源码分析

默默地敲出Bug

于 2023-03-29 09:42:43 发布

阅读量186

点赞数 1

分类专栏：数据结构(JAVA语言) 文章标签：哈希算法 java 数据结构

本文链接：https://blog.csdn.net/Jiali_1/article/details/129830364

版权

数据结构(JAVA语言) 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

JDK1.8中的HashMap源码分析

文章目录

JDK1.8中的HashMap源码分析

在讲解之前先思考一下为什么需要Hashmap？如果我们想在顺序表中查找某一个记录时，通常都是从表头开始，挨个地比较记录a[i]与key的值是 “==” 还是 “!=” ，直到有相等才算是查到了，这种挨个遍历（即线性查找）的最坏时间复杂度可想而知是O(N)。如果顺序表的元素是有序的情况下，我们可以利用a[i]与key的 “<” 或 “>”来折半查找，直到相等时查找成功并返回i下标，此时的复杂度降到了O(logN)。这两种查找方式都是在 “比较”，当元素增多时比较的次数也随之增加，想一想这种比较是否真的有必要？能否直接通过关键字key得到要查找的记录的内存存储位置呢？

当然是有的，我们可以通过某个函数ƒ , 使得 存储位置 = ƒ(关键字)

这种方法称为散列技术，**散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系ƒ，使得每个关键字key对应一个存储位置ƒ(key)。查找时，根据这个确定的对应关系找到给定值key的映射ƒ(key)，若查找集合中存在这个记录，则必定在ƒ(key)的位置上。这里我们把这种对应关系ƒ称为散列函数，又称为哈希（Hash）函数。**按这个思想，采用散列技术将记录存储在一块连续的存储空间中，这块连续存储空间称为散列表或哈希表（Hash Table）。那么关键字对应的记录存储位置我们称为散列地址。

摘自《大话数据结构》

有了这种方法，今后我们无论是在哈希表中添加、删除、修改、查找元素都可以将时间复杂度尽量控制在O(1).

Java中的HashMap就是实现了散列技术的容器类，我们通过分析源码中最主要的几个方法来更加深刻地理解哈希表这种数据结构。

一、HashMap的底层数据结构

在Jdk1.8中，HashMap底层是 动态数组 + 单链表 + 红黑树。

表中的结点以Node表示

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash; // 保存Key的哈希值
    final K key; // 实体Key
    V value; // 实体Value
    Node<K,V> next; // 下一个结点的引用

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    // ...省略...
  
}

动态数组的属性

Node<K,V>[] table; // 实体数组
int size; // 表中存放的记录个数
int threshold; // 扩容阈值，当达到时则触发扩容
final float loadFactor; // 装填因子

二、HashMap()构造方法

// 这里创建一个map对象
HashMap<String, String> hashmap = new HashMap<>();

此时会调用到如下无参构造方法：

public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // 只初始化了装填因子，其他属性都为默认值
}

loadFactor为装填因子，所谓的装填因子α = 填入表中的记录个数 / 散列表长度。α标志着散列表的装满程度。填入表中的记录越多，α就越大，产生冲突的可能性就越大。比如散列表的长度为12，填入表中的记录个数为11，那么此时的装填因子α=11/12=0.9167，再填入最后一个记录时产生冲突的可能性就非常之大。

光构造一个map对象根本看不出来什么，我们来看看往map中添加元素的过程。

三、写入数据操作 — put()方法

// 往表中添加一个元素
hashMap.put("张三",18);

// 调用put方法，put方法里面调用putVal，putVal是真正来存放元素的方法，put是更方便的公开接口，这样做是为了屏蔽细节部分，因为我们调用put方法就是为了存键值对，不会去也不想管其他参数。
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

进入putVal方法前会先去调用hash(key)方法来计算出当前key的哈希值，这个哈希值还不是元素的存储位置。

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); // 这里的计算细节我们不深究，主要是为了让哈希值分布的更均匀，减少哈希冲突的可能性。
}

来看putVal()方法的逻辑

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; // 实体元素数组的引用
    Node<K,V> p; // 元素节点的引用
    int n, i; //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) // 若添加该元素后超过了树化的阈值
                        treeifyBin(tab, hash); // 将单链表升级为红黑树
                    break;
                }
                if (e.hash == hash && // 若该链表上的某一个节点与当前要put的元素相同
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key 存在相同的key
            V oldValue = e.value; // 保存原KeyValue元素的value
            if (!onlyIfAbsent || oldValue == null)
                e.value = value; // 新value覆盖掉原value
            afterNodeAccess(e);
            return oldValue; // 返回原value
        }
    }
    ++modCount;
    if (++size > threshold) // 如果本次添加元素后超过了阈值，则进行扩容
        resize();
    afterNodeInsertion(evict);
    return null; // 添加成功，返回null
}

// 数组扩容方法
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table; // 指向原数组的引用
    int oldCap = (oldTab == null) ? 0 : oldTab.length; // 获取原数组的长度（首次添加时为0）
    int oldThr = threshold; // 获取原阈值（首次添加时为0）
    int newCap, newThr = 0; // 新数组长度和新阈值
    if (oldCap > 0) { // 若原数组不为空
        if (oldCap >= MAXIMUM_CAPACITY) { // 是否超过最大容量
            threshold = Integer.MAX_VALUE; 
            return oldTab; // 超过则不进行扩容
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && // 将新数组长度扩容为原长度的2倍
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY; // 首次添加元素时将新数组长度设为16
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 首次添加元素时将阈值设为12
    }
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr; // 设置map对象的阈值，首次添加即为12
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // 开辟实体元素数组空间，长度为newCap（首次添加元素则是16）
    table = newTab; // 将map对象中实体元素数组的引用指向为新开辟数组的地址
    if (oldTab != null) { // 如果原数组不为空，则将其中保存的所有元素重新计算哈希值，然后根据算出来的下标位置放到新数组中
        for (int j = 0; j < oldCap; ++j) { // 遍历原数组的所有下标位置
            Node<K,V> e; // 引用当前下标上的元素
            if ((e = oldTab[j]) != null) { // 如果当前下标不为空
                oldTab[j] = null; // 将原数组j下标指向置空
                if (e.next == null) // 如果当前元素为单节点
                    newTab[e.hash & (newCap - 1)] = e; // 重新计算在新数组中的存储位置并存入
                else if (e instanceof TreeNode) 
                    // 为红黑树则进行树拆分，此过程可能会将其退化为单链表
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    // 链表元素重新哈希
             	    // ...省略...
                }
            }
        }
    }
    return newTab;
}

四、读取数据操作 — get()方法

// 查询指定Key映射的Value
public V get(Object key) { 
    Node<K,V> e;
    // 计算Key的哈希值，然后在表中查询
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

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 && // 从第一个节点开始判断是否匹配Key
            ((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 && // 如果该链表上的某个节点与Key匹配则直接返回
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null; // 表中不存在该Key的映射
}

五、删除数据操作 — remove()方法

// 删除指定Key的键值对
public V remove(Object key) {
    Node<K,V> e;
    // 计算key的哈希值，然后删除指定Key的映射
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; // 实体数组引用
    Node<K,V> p; // 节点引用
    int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 && // 若实体数组不为空，且计算出来的下标位置上有元素
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; 
        K k; 
        V v;
        if (p.hash == hash && // 判断当前指向的节点是否匹配
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p; 
        else if ((e = p.next) != null) { // 遍历该下标位置上的链表
            if (p instanceof TreeNode) // 如果是树节点，则执行红黑树的查找操作
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                do {
                    if (e.hash == hash && // 如果该链表上的某个节点与Key匹配
                        ((k = e.key) == key ||  (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        if (node != null && (!matchValue || (v = node.value) == value || // 如果node不为空则匹配到了要删除的key
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode) // 如果是树节点，则执行红黑树的删除操作
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p) // 如果是链表头节点则进行头删
                tab[index] = node.next;
            else
                p.next = node.next; // 将匹配的节点从链表中删除，即让匹配节点的上一个节点的next执行匹配节点的next
            ++modCount;
            --size; // 表长度-1
            afterNodeRemoval(node);
            return node; // 返回删除的节点
        }
    }
    return null; // 没有与之匹配的节点，返回null
}

六、总结

HashMap类的核心技术就是利用散列函数计算出Key在数组中存放的位置，数组中元素的读写和删除操作都是围绕着散列函数展开的。通过源码分析，可以得出以下结论：

实例化map对象时，只是初始化了一些数组相关的参数，并没有真正创建动态数组，而是第一次put元素的时候创建的，属于懒加载机制，目的在于避免提前开辟了内存空间而不使用。
当put元素时，有三种情况：

如果哈希计算出来的下标位置上没有存放元素，则直接放入该位置。
如果哈希计算出来的下标位置上有元素，则该位置上可能是多个节点组成的单链表或红黑树结构，此时通过比较Key来判断，若Key与某个节点的Key匹配，则覆盖原Value并返回旧Value。
如果遍历完链表或树都没有发现匹配的Key就插入元素，链表是尾插，树则进行树的节点插入操作。

插入元素后如果达到了阈值，会进行扩容。

若某次put元素后该下标位置上的链表节点超过了树化的阈值8且表中记录个数超过64，则会将该下标上的单链表升级为红黑树，若某次删除元素操作后树的节点小于或等于6了，会在合适的时机将树退化成单链表结构。

默默地敲出Bug

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JDK1.8中的HashMap源码分析

在讲解之前先思考一下为什么需要Hashmap？如果我们想在顺序表中查找某一个记录时，通常都是从表头开始，挨个地比较记录a[i]与key的值是 “==” 还是 “!=” ，直到有相等才算是查到了，这种挨个遍历（即线性查找）的最坏时间复杂度可想而知是O(N)。如果顺序表的元素是有序的情况下，我们可以利用a[i]与key的 “”来折半查找，直到相等时查找成功并返回i下标，此时的复杂度降到了O(logN)。这两种查找方式都是在 “比较”，当元素增多时比较的次数也随之增加，想一想这种比较是否真的有必要？
复制链接

扫一扫