Map族系——HashMap

最新推荐文章于 2022-10-10 16:23:54 发布

袁小黑

最新推荐文章于 2022-10-10 16:23:54 发布

阅读量261

点赞数 1

分类专栏： Java基础&源码解析

本文链接：https://blog.csdn.net/ydonghao2/article/details/81079249

版权

Java基础&源码解析专栏收录该内容

55 篇文章 1 订阅

订阅专栏

本文以Java10为背景，Java8到Java10只是增加了一些方法，总体结构没变。
转载请注明：https://blog.csdn.net/ydonghao2/article/details/81079249
TalBen

首先我想实现一个map存储key－value，很多key－value，并且map是可以修改的。（不可以修改的参考：ImmutableCollections和Map族系详解 —— Map）那么我除了要implement Map之外，还得想办法存储key－value，并且一定要public put方法。

好，为了方便我将key－value存储在数组中，但是每次put的我的数组都拓展很麻烦，怎么办呢？可以用key的hash值来决定存放到哪个index中。

HashMap可以说是我们使用最多的一种类型之一。

这里来探究以下HashMap的原理。

上图是HashMap的主要设计，Serializable、Cloneable不讲。HashMap是Map和Abstract Map的一种实现。Node、TreeNode、HashIterator、KeyIterator、EntryIterator、ValueIterator、KeySet、EntrySet、HashMapSpliterator，Values，ValueSpliterator、KeySpliterator...都是HashMap的内部类。

它的主要思想前面有简单介绍过。既然是想把key－value存在数组中，在java中你想使用数组，你得先声明你要使用多大的数组，以此DEFAULT_INITIAL_CAPACITY定义的就是数组的长度。

//这是Jdk中的定义，1<<4的结果是16，2的4次幂，为什么使用位运算呢？位运算的虽然很难读，
//但是计算机执行效率非常快，底层架构本就可能使用比较多的位运算。
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

//这是int中2的n次幂中最大的数。
static final int MAXIMUM_CAPACITY = 1 << 30;

static final float DEFAULT_LOAD_FACTOR = 0.75f;

static final int TREEIFY_THRESHOLD = 8;

static final int UNTREEIFY_THRESHOLD = 6;

static final int MIN_TREEIFY_CAPACITY = 64;

Hash()

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

这里提一个问题：为什么不用key.hashCode()？而是要h>>>16? (>>> : 无符号右移，忽略符号位，空位都以0补齐)

为什么高16位和低16位做异或？这些问题我们留到后面慢慢说。

tableSizeFor()

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

这个算法是求距离cap最近的2的n幂。因为HashMap的容量本身就只能是2的n次幂。首先我们得清晰得认识到2的n次幂的二进制是10,100,1000,10000.....有这个意识之后我们再去推导怎么求距离cap最近的2的n次幂。

我们转换一下问题：给定任意一个int类型的正数二进制形式，然后求距离这个正数最近的2的n次幂。正数的范围是1～2^31 －1，二进制的范围是2，2^2，2^3，2^4... 2^31。（为什么设置这个范围？因为int是4bit，支持32位二进制。）

那我们在观察一下：输入是任意一个int类型的正数二进制形式，输出是10,100,1000,10000....

那么 (下面是二进制)

10＝01+1,

100 = 011+1 ,

1000 = 0111+1

...

这个问题再转换为怎么让该二进制第一个非零数开始到最后一个数都变成1。所有便有了

        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;

为什么开始的数cap要减1呢？细心的同学可能已经知道：因为遇到给的数本身就是2的n次幂时，按照上面的算法会得到2的n+1次幂。所以减1，并且减1对所有的非2的n次幂的数都没影响。（太好证明，这里不验证。）

HashMap的Field

    /* ---------------- Fields -------------- */
    //transient 是不序列号的修饰符。
    transient Node<K,V>[] table;

    transient Set<Map.Entry<K,V>> entrySet;

    transient int size;

    transient int modCount;

    int threshold;

    final float loadFactor;

定义存储key－value的table的Node结构是什么呢？为什么要这样定义呢？

我们先看看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;
        }
    }

以上的代码很简单就不介绍了。为什么这样设计？我们可以把这个问题留到后面。

HashMap的构造方法

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //Float.isNaN() isNaN: is not a number
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

所有的构造函数都是在给loadFactor、threshold赋值。但是这里也有一些问题：比如为什么有的设置了threshold有的没设置呢？我们后面可以慢慢讲。

核心方法

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;
            //p 就是 put进来的值该放的位置上的值，在前面已经赋值过了，
            //这个条件表示put进来的值和放在这个位置上的key是相同的，则这个node需要被替换
            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 {
                //遍历这个链表p
                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
                            //链表大于size大于8，转换成二叉树
                            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这个方法只在LinkedHashMap中有使用，在这里没什么用，运用了模板模式
                afterNodeAccess(e);
                return oldValue;
            }
            //制作链表
        }
        ++modCount;
        if (++size > threshold)
            resize();
        //afterNodeInsertion这个方法只在LinkedHashMap中有使用，在这里没什么用，运用了模板模式
        afterNodeInsertion(evict);
        return null;
    }

好，注意到if ((tab = table) == null || (n = tab.length) == 0)。在使用put之前table是空的，table的长度也没扩展，这个时候就调用后面的resize()。resize方法会去扩容。

第二个condition是(p = tab[i = (n - 1) & hash]) == null；在解释这个意思之前，我们得先理解table这个数组长度有n这么长，那么你新put进来的node该放在哪儿呢?根据（n－1）& hash定位到是哪就是哪，n是2的n次幂的二进制形式，所以用n－1做&就是通过计算hash的第0～n－1位的值来决定放哪儿。所以如果hash的低n－1位是随机的，那么放的位置也是随机的。这个条件的意思就是tab[i = (n - 1) & hash])这个位置还是空，还不是链表，你可以直接放进来。

上述说到hash低n－1位是随机的话就可以做到数组table分布也是随机的，但是连作者也不知道hash到底会出来什么鬼，分布均匀不均匀都是随机的，这种情况下，作者抛弃了直接使用key.hash做hash值，而是使用了前面提及的hash()，没错前面遗留的为什么hash()要做高十六位和低十六位的异或的问题，答案是：为了更多的让hash值参与运算，让hash值分布尽量均匀。然后做到存放key-value值尽量均匀。

接着第二个condition的else表示这个key对应到位置已经有人了，请做链表。

其实大部分情况下：如果你给的key如果是有规律的，大部分会执行tab[i] = newNode(hash, key, value, null); 这样可以避免内存浪费。到时候很有可能是HashMap只是对数组的封装而已。

小编试过

hashmap.put(String.valueOf(i*Math.random()) , (int) (100000*Math.random()));

当连续put 1亿个值才装进二叉树中，当时hashmap.size也只有6百多万。所以大部分情况下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;
        计算要扩容多少
        if (oldCap > 0) {
            //table已经存了东西。
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //扩容两倍
            //<<:左移运算符，num << 1,相当于num乘以2
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        //通过HashMap(int initialCapacity, float loadFactor)初始化的时候构造了阀值，才会设置进这里
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
        //HashMap()定义就会进入这里。
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //newThr是新的阀值，也是这里最终结果，0往往是之前table的size就是0，并且不是通过HashMap()进行构造map的。
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        
        threshold = newThr;
        计算要扩容多少
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        //这里只是让table指向newTab数组的内存地址，所以对newTab所有的操作都可以对table有效，这个方法也是直接返回table就可以了。
        table = newTab;
        //table原先有值
        if (oldTab != null) {
            //遍历原先数组中所有的值
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    //将旧值给e，原先的地址复位为null。
                    oldTab[j] = null;
                    if (e.next == null)
                        //重新计算地址：可以参考https://blog.csdn.net/bnmb888/article/details/77164485
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        //如果原先这个节点是TreeNode，就做split操作
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        //扩容之后，如果原来是链表，则会把链表拆分两个。
                        //拆分的规则是：e.hash & oldCap, 前面我们说过容量都是2的n次幂，
                        //所以oldCap的二进制只有一位bit是1，其它都是0，那么就是判断e.hash
                        //的第n位是否是1，如果保证e.hash的第n位有随机性，就做到均匀分布。
                        Node<K,V> loHead = null, loTail = null;//lo:low，低位的链表
                        Node<K,V> hiHead = null, hiTail = null;//hi:high， 高位的链表
                        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;
    }

resize方法是空间不够时都会调用的方法。详细情况可以看注解。

Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];这个就是存储数组的结构了。

HashMap会在两种情况下扩容：

size > threshold 元素的个数大于阀值

tab.length < MIN_TREEIFY_CAPACITY这种情况比较极端：表的长度还没达到64，需要扩容，这样可以避免resize和树之间的两个动作同时执行的冲突。

TreeNode

红黑二叉树的部分请看：

红黑二叉树

袁小黑

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Map族系——HashMap

本文以Java10为背景，Java8到Java10只是增加了一些方法，总体结构没变。转载请注明：https://blog.csdn.net/ydonghao2/article/details/81079249TalBen目录Hash()tableSizeFor()HashMap的FieldHashMap的构造方法核心方法put()resize()Tre...
复制链接

扫一扫