HashMap源码逻辑性地解析

最新推荐文章于 2022-11-22 23:53:08 发布

花晨千夏

最新推荐文章于 2022-11-22 23:53:08 发布

阅读量178

点赞数 1

分类专栏： HashMap

本文链接：https://blog.csdn.net/qq_35496815/article/details/101193312

版权

HashMap 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

ok，先来说下为什么一定要搞懂HashMap源码，首先最近面试的时候经常被问到；其次呢，探索为什么是一个优雅的程序员的良好习惯。好了，不多比比，下图呢是我从https://www.processon.com 这个上面下载下来的，发现越来越觉得学习一个东西，有一个思维脑图是很关键的。
这样看来，上面那一条线是一个数组，蓝色的是链表，然后就是红黑树了。jdk1.8相对与1.7的数据结构就是多了红黑树；相信同学们能想到搞明白HashMap，那么对数据结构就不陌生了。
好了，现在我们可以明朗的得到了它的结构，下面呢就是怎么用代码的形式来实现它。HashMap这个对象里面是不是有数组；链表；红黑树这几个属性。
带着这个想法，于是你看到了这里；

    /**
     * The table, initialized on first use, and resized as
     * necessary. When allocated, length is always a power of two.
     * (We also tolerate length zero in some operations to allow
     * bootstrapping mechanics that are currently not needed.)
     */
    transient Node<K,V>[] table;

然后呢，你就会想，既然是数组，它都会一个数组长度对吧。

    这个是数组的默认的初始大小是16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    最大值是2的30次方。
    static fi`在这里插入代码片`nal int MAXIMUM_CAPACITY = 1 << 30;
    这个是加载因子，就是当你的数组长度超过12的时候开始扩容，为什么？这个是经过科学家          经过大量的实验得出来的一个值。
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

这段注释一大堆其实就是想告诉你，这是一个数组，不参与序列化。

 /**
     * Basic hash bin node, used for most entries.  (See below for
     * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
     */
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

哇，下面你找到了这一段，是不是我们熟悉的单链表的结构。
大家都知道，单链表在查询的时候的效率是非常低的，它不会一直无限长把，好的，有这么一段注释。

/**
     * The bin count threshold for using a tree rather than list for a
     * bin.  Bins are converted to trees when adding an element to a
     * bin with at least this many nodes. The value must be greater
     * than 2 and should be at least 8 to mesh with assumptions in
     * tree removal about conversion back to plain bins upon
     * shrinkage.
     */
    static final int TREEIFY_THRESHOLD = 8;

意思是如果单链表的长度超过8的时候，会把链表转成红黑树。这个感兴趣的同学可以自己动手实现下。

 static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;

/**
     * The bin count threshold for untreeifying a (split) bin during a
     * resize operation. Should be less than TREEIFY_THRESHOLD, and at
     * most 6 to mesh with shrinkage detection under removal.
     */
     如果你的红黑树节点数小于6的话就会变成链表
    static final int UNTREEIFY_THRESHOLD = 6;

好了，这些Hash源码中都体验到了，

看到这儿，你是不是会想，你总说超过大写扩容什么的？那我怎么知道它，总得有一个属性吧？ok

 /**
     * The number of key-value mappings contained in this map.
     */
    transient int size;

这个就是来记录数组格子的大小，
size=0的时候，我每次添加都会进行一次size++;好的，我们来找这段代码

if (++size > threshold)
            resize();

threshold是默认初始化容量；

你又开始想了，我知道hashmap里面有一个hash算法，它是干嘛的呀？我每次put一次操作的时候，我怎么去落点呢？
数组的默认大小是16；所以它的角标是0-15；怎么控制它的落点
我们先看一下putval的源码

 /**
     * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * 如果是true，则不修改现有值
     * @param evict if false, the table is in creation mode.
     * 
     * @return previous value, or null if none
     */
    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;
                }

哇塞，看到这儿头都大的同学点个赞好吧。我们来一句一句的看。

 Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

首先声明了一个数组，然后是一个节点。然后对数组进行了初始化的操作就是resize()。我们来看一下这个源码：

 /**
     * Initializes or doubles table size.  If null, allocates in
     * accord with initial capacity target held in field threshold.
     * Otherwise, because we are using power-of-two expansion, the
     * elements from each bin must either stay at same index, or move
     * with a power of two offset in the new table.
     *
     * @return the table
     */
    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;

初始化数组数组或者给它扩容，如果为空，则分配与初始容量目标保持一致。否则，因为我们使用的是二次展开的幂，所以每个bin中的元素必须保持在同一索引中，或者移动在新表中使用两个偏移量的幂。

 newCap = DEFAULT_INITIAL_CAPACITY;
 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

threshold = newThr=12;
然后这个数组初始化一下，赋值
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;

然后执行完这个resize()，返回什么就不用多说了吧，返回了一个Node<K,V>[]嘛。
好了，现在你又开始想了，我怎么放Node<K,V>呢；ok
于是你开始想：
（1）数组原本的位置为空；
（2）数组原本的位置不为空；是单链表结构；
（3）数组原本的位置不为空；是红黑树的结构；

   if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);

这里是如果为空，就创建一个新的节点，就可以放了。对应第一种情况
已知n=16;那么我们来论证下 15&hash == hash%16 ?
我们随便得到一个hash值 694528
他的二进制的表示110 1001 0100 0101 0010 1000 &
0 1111
的结果是什么呢，是0嘛。如果要是32个1跟它比较呢计算结果就是1111就是15.所以它的落点也是0-15；这两种表示的结果是相同的.
为了让数组的每一个位置都能用到；那么它的每次落点就要不同；我们来看一下hash算法

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

这里我们可以理解成高16为和低16为进行异或运算。这样结果才尽可能不同。
2）数组原本的位置不为空；

else{
            Node<K,V> e; K k;
            //如果key已经存在了，我们只是一个赋值的操作
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //如果p要插入到红黑树上了，我们把它类型转换一下，
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //那么接下来就是链表了，我们说过链表；什么时候才可以插入，是不是要从头开始遍历找到一个指针为null的呀，
            else {
               这里进行了遍历
                for (int binCount = 0; ; ++binCount) {
                    //如果它的指针时空，那么可以创建了
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //如果链表的长度大于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;
                }
            }
            //如果不为空，说明已经有了value的替换，所以我就返回oldValue 
            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;

OK，到这里，我们对put值的一个源码解析已经完成了；后续呢我会再看下get的操作