知识图谱整理之Java基础HashMap

最新推荐文章于 2023-04-28 23:15:30 发布

向光奔跑

最新推荐文章于 2023-04-28 23:15:30 发布

阅读量147

点赞数

分类专栏： Java基础知识图谱文章标签： HashMap 源码

本文链接：https://blog.csdn.net/itslz/article/details/101349875

版权

Java基础同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

知识图谱

10 篇文章 0 订阅

订阅专栏

本系列完善自己的知识图谱，更从容的表达描述

HashMap介绍

HashMap是一个用于存储Key-Value键值对的集合，每一个键值对也叫做Entry。这些个键值对（Entry）分散存储在一个数组当中，这个数组就是HashMap的主干。

这里再做个前提，我这分析的是JDK1.8的源码

Hash数据存储

我们先从数据存储的结构进行说起，直接来看下源码内部类实现：

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

我们可以看到，在HashMap中我们实现了Map中的Entry接口，那么我们先来看下Entry的接口定义：
Map的Entry接口

上面4个comparing方法是在Entry中实现的静态方法，有兴趣的同学可以去看下，我们重点放在Node实现的几个方法上：

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V 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;
        }

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

这里的重点其实就一个hashCode方法的计算，把key的hashCode和value的hashCode做或运算

数据容量计算

之前都是听说，说HashMap的容量都是2的n次方，自己想没想出来会如何实现，下面我们看下jdk使用位运算来实现的代码：

    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

可能刚开始你跟我一样看不懂，有点懵，我也是看了他人的运算过程才明白的，我贴一下图：

HashMap参数字段介绍

我们下来看下HashMap中包含的字段：

/**
 * 用来实际存储数据的
 */
transient Node<K,V>[] table;

/**
 * 用来对应keySet方法
 */
transient Set<Map.Entry<K,V>> entrySet;

/**
 * HashMap的key-value mappings的数量
 */
transient int size;
/**
 * 记录HashMap内部结构发生变化的次数，主要用于迭代的快速失败。
 */
transient int modCount;
/**
 * 下次扩容阈值
 */
int threshold;
/**
 * 负载因子
 */
final float loadFactor;

HashMap重要操作介绍

构造函数

这里直接取一个最全的构造函数进行说明，其他不设置的都是按照默认参数。如果你问我默认参数是多少？好吧~ 就是默认容量是16，默认负载因子是0.75.

接下来就直接看源码：

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);                         
        //MAXIMUM_CAPACITY = 1 << 30, 为HashMap最大容量
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        // 这个方法不懂往上翻数据容量计算，简单说就是设置为向上去2的n次方值
        this.threshold = tableSizeFor(initialCapacity);
    }

get方法解析

下面就来看常用的get方法的源码：

   public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

这里比较简单，我们先来看下hash这个方法：

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

这里主要就是key的hash计算，至于为什么要这么计算？下面是我的想法，如果不对请指正：

我喜欢用反证法的思路去思考，如果不这样计算，而是直接key.hashCode就可以了会有什么问题么？OK，那首先，我们之前看了放真实数据的是Node[]数组，那么我们应该也知道这个计算出来的hash值是用来定位到放在数组中的那个索引下标下的。有这个前提下，我们继续思考，因为正常情况下像默认数组长度是16的情况下，我们可能取得hashCode值经过位运算得出索引下标后，其实就是hashCode的后面几位值在参与计算，和其他生产的位数没有关系，这就可能造成hashCode的冲突几率增大。而现在这样做之后，我们可以让高位也参与运算，使索引下标更加平均。

我们继续来看下一个getNode源码：

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

先自问下能否看懂这个方法？
接下来我们一层层进去，首先是最外层的if方法内容 (tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null前面两个判断很简单，主要是 tab[(n - 1) & hash]可能有人会疑惑，这里的(n - 1) & hash是用来进行索引下标计算的，如果你不太熟悉，可以等价于取模运算
下面是first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k))是判断首节点是否匹配，如果匹配直接返回
在下面的代码就不贴了，我们可以看到首先是判断是否是树节点，如果不是则进行单链表查询
再总结下把，这里我将不继续展开数结构下的取值，但是大致流程记录下。这里的树在JDK1.8之后会变回红黑树（平衡二叉树），可以缩短我们的查找，当链表长度为8时会进行这个变幻。当链表长度退化到6之后会继续变回链表，至于为何不一致，你们可以自己思考下哦~~ 哈哈
put方法解析

废话不多说，直接进入源码：

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

我们也是继续一步步顺序下来，首先判断是否为null或者长度等于0，如果是则进行扩容，至于怎么扩容我们下面会说到
之后会判断Node数组下是否存在对应索引下标的值，不存在的话直接创建Node。
如果存在的情况下，也就是发生hash碰撞的情况下，不看我们也知道肯定会分为两种情况，一种是树节点的情况，一种是链表的情况。
这里先是判断头结点的值是否相等，如果相等就直接修改就行了。
下面我也只是介绍链表法是如何进行插入的，关于树节点的插入我不做展开
这里有个骚操作可能有点难理解，这里是先查询下一个节点是否为null，不为null就新增下一个节点，如果大于转化为树的阈值后就变树。如果在链表上匹配上了key，就会进行覆盖。之后有个细节大家不知道有没有注意，如果是覆盖的话，直接return，不会进行下面的modCount和size的自增操作。
这里关于两个afterNodeAccess、afterNodeInsertion是保留方法，在HashMap中没有用到。
resize方法解析

终于到了我们最后一个要讲的方法了，我们进入正题：

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        //<1>
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     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;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        //<2>
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    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
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

这个方法相对比较长了，我们耐心来看，也不会太难。
根据我代码中的序号来进行阅读
<1> 标签下，干了关于到底扩到多大，然后计算下次扩容阈值这个事。具体怎么计算大家也知道了，容量是2的n次方，阈值是容量*负载因子。
<2> 标签下的扩容，这一部分是核心也是最难看懂的地方，我分析的仔细一点。这里的主体思想是吧原来的一个链表分成两个，然后分别放入到扩容之后的数组中。这边就有一个精髓的地方了，也是你可能不理解的地方，就是分配的原则是什么？我们来看下条件e.hash & oldCap，能看出什么么？如果不能，我们再来看下之前计算的时候，我稍微改一下e.hash & oldCap -1，对比一下，能理解么？OK，假如还不能理解，那我直接说明一下，首先我们这里的扩容是需要每次扩展两倍的，这里是有原因的，也是提前规定好的。在这个前提条件下，如果是让你重排，你会怎么做？我想大多数人应该都知道，是通过hashCode计算与老的数组容量的取模运算和与新的数组容量的取模运算进行分开，这个应该不难理解。但是写JDK的人是谁，那是茅房拉屎脸朝外的汉子，他们直接用了位运算来解决。怎么解决的，首先你要知道这个oldCap肯定是2的n次方的，换算成二进制也就是某高位数是1，下面全是0，在我们计算下标索引的时候为什么要把oldCap-1，就是把0变1来进行截取。现在直接与oldCap与运算之后，拿到了那个高位之后，我们就可以获取到这个hash分配到哪了。再不懂，OK，我盗个图：

到了这大致把HashMap的所有操作方法都讲完了。

HashMap为什么线程不安全

这个问题也是在面试过程中经常会问到的一个点，我总结基本会发生在以下两种场景下。

第一种场景是Hash碰撞下产生的

这里我就不画图描述了，我们脑海中推演。

前提：有两个线程，计算出的数组索引下标是相同的，这里我们简单点，就当Node[]数组下那个索引下还没有Node值，还为null，这个时候线程一进来了，刚查看到这个位置为null，往下运行想插入值，OK这个时候CPU分片结束了线程一，到了线程二，也查看到这个位置是为null(因为这个时候线程一还没插入)，OK，之后插入完成后会怎么样？是不是肯定会丢失一个数据呢？

第二种场景是发生在resize场景下，其实发生的原因也和上述差不多，这里可以自己品味下，不过唯一的不同是，在JDK7和JDK8的过程中还不一样。因为JDK7在重新分配链表数据的时候是用的头插法，会造成环形链表，导致CPU飙升。在JDK8中不会出现这个问题

今日知识图谱输出

知识图谱

今天就到这，欢迎有志者一起交流学习

向光奔跑

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
知识图谱整理之Java基础HashMap

本系列完善自己的知识图谱，更从容的表达描述HashMap介绍HashMap是一个用于存储Key-Value键值对的集合，每一个键值对也叫做Entry。这些个键值对（Entry）分散存储在一个数组当中，这个数组就是HashMap的主干。Hash数据存储...
复制链接

扫一扫