面试必备：HashMap底层源码原来是这么简单（分析）

news2024/9/22 2:13:50

微信公众号：SteveCode
关注可了解更多的编程及开发经验。问题或建议，请公众号留言;
专注Java技术干货分享，Java技术、数据结构、相关工具、Spring全家桶、intellij idea……
如果你觉得对你有帮助，欢迎赞赏

在这里插入图片描述
transient 发现了这个关键字：（不懂啥意思）赶快去查一下

transient 只能修饰变量哈！被他修饰的变量不能序列化。

什么是序列化和序列化

序列化：对象转字节，反序列化：字节转对象

什么时候会用到实例化

想将对象做网络传输或者写入数据库、文件夹流中

transient帮助文档

为什么要用modCount

也就相当于版本控制。当你在增删改的时候都会 ++modCount。

public final void forEach(Consumer<? super K> action) {
            Node<K,V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
            // 刚开始把modCount 复制给mc 
                int mc = modCount; 
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K,V> e = tab[i]; e != null; e = e.next)
                        action.accept(e.key);
                }
               // 循环完了之后在看一下 modCount 有没有发生改变 。如果发生就说明 这个集合内部数据有改变。就报：ConcurrentModificationException
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }

容量与扩容机制

hashMap 默认容量为 DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
最大容量：MAXIMUM_CAPACITY = 1 << 30;
负载因子默认：DEFAULT_LOAD_FACTOR = 0.75f

注意扩容机制容量和hashmap默认容量不能搞混了哈！

之前我一直任务hashMap 的默认容量为 DEFAULT_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR=12【错误的】
扩容机制：集合的size大小达到size=12的时候才会发生扩容。

在这里插入图片描述

JDK8的HashMap为什么要引入红黑树

当HashMap的key冲突过多时，会导致链表过长。而链表的查询效率很差，因此引入红黑树优化查询效率。

为什么当链表长度大于8-1 并且 table >64 时候才会转红黑树而不是一开始直接使用红黑树：

树节点占用空间是普通节点的两倍，因此在开始较短时候使用链表，占用空间少，查询性能也相差不大。但是当链表越来越长，查询效率逐渐变低，为保证查询效率才会舍弃链表转为红黑树，以空间换时间。

根据统计，HashMap链表长度为8的概率仅有不到千万分之一，这时链表的查询性能很差了。在这种极端罕见的情况下才会将链表转换为红黑树。

底层源码分析

 public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
调用
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
         // tab p 当前方法初始化一个
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // tab = table这个还没初始化 ==null   这个数组没有实例化  tab.length=0
        if ((tab = table) == null || (n = tab.length) == 0)
        // 初始化数据或者扩容的方法 resize()
            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);
                        // 什么时候转红黑树：链表长度 >= 8 - 1 &&数组长度.length > 64
                        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;
                }
            }
            // key相同的时候走
            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;
    }