HashMap不得不知道的那些事儿

主要是根据Hashmap源码来近距离了解庐山真面目;

为什么要写,因为面试经常问啊,而且9%的程序员都知道也用过;而且它涉及的知识远远不止put和get那么简单,有必要知晓,也有利于对数据进行灵活的存储引用;

源码 jdk 1.8

2、知识铺垫

涉及知识点:hash算法,单链表、双链表、红黑树、二叉搜索树

2.1 单链表

单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的,每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置),元素就是存储数据的存储单元,指针就是连接每个结点的地址数据。

单链表的实际使用场景并不多,比如只是频繁对头/尾结点进行操作,单链表最佳

2.2 双链表

双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

双链表的主要优点是对于任意给的结点,都可以很轻易的获取其前驱结点或者后继结点,而主要缺点是每个结点需要添加额外的next域,因此需要更多的空间开销,同时结点的插入与删除操作也将更加耗时,因为需要更多的指针指向操作。

2.3 二叉搜索树

二叉排序树,又称二叉查找树,亦称二叉搜索树,满足下面性质

  1. 若左子树不空,则左子树上所有结点的值均小于它的根结点的值;
  2. 若右子树不空,则右子树上所有结点的值均大于它的根结点的值;
  3. 左、右子树也分别为二叉排序树;
  4. 没有键值相等的结点。

2.4 红黑树

红黑树是每个节点都带有颜色属性的二叉查找树,颜色或红色或黑色。 在二叉查找树强制一般要求以外,对于任何有效的红黑树我们增加了如下的额外要求:

  • 性质1. 节点是红色或黑色。
  • 性质2. 根节点是黑色。
  • 性质3.所有叶子都是黑色。(叶子是NUIL节点)
  • 性质4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
  • 性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

这些约束强制了红黑树的关键性质: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。结果是这个树大致上是平衡的。因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例,这个在高度上的理论上限允许红黑树在最坏情况下都是高效的,而不同于普通的二叉查找树。

性质4导致路径上不能有两个连续的红色节点。最短的可能路径都是黑色节点,最长的可能路径有交替的红色和黑色节点。因为根据性质5所有最长的路径都有相同数目的黑色节点,这就表明了没有路径能多于任何其他路径的两倍长

2.5 Hash算法

希算法并不是一个特定的算法而是一类算法的统称。哈希算法也叫散列算法,一般来说满足这样的关系:f(data)=key,输入任意长度的data数据,经过哈希算法处理后输出一个定长的数据key。同时这个过程是不可逆的,无法由key逆推出data。

如果是一个data数据集,经过哈希算法处理后得到key的数据集,然后将keys与原始数据进行一一映射就得到了一个哈希表。一般来说哈希表M符合M[key]=data这种形式。
哈希表的好处是当原始数据较大时,我们可以用哈希算法处理得到定长的哈希值key,那么这个key相对原始数据要小得多。我们就可以用这个较小的数据集来做索引,达到快速查找的目的。

稍微想一下就可以发现,既然输入数据不定长,而输出的哈希值却是固定长度的,这意味着哈希值是一个有限集合,而输入数据则可以是无穷多个。那么建立一对一关系明显是不现实的。所以"碰撞"(不同的输入数据对应了相同的哈希值)是必然会发生的,所以一个成熟的哈希算法会有较好的抗冲突性。同时在实现哈希表的结构时也要考虑到哈希冲突的问题。

3、源码分析

主要包括数据结构、扩容、删除、添加、获取过程

3.1 数据结构

数组+单链表+双链表-黑红树

3.1.1 数组

transient Node<K,V>[] table;
复制代码

整体来说采用数组存储,以hash值和数组大小得到数组位置

3.1.2 单链表

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;
        }
    }
复制代码

单链表数据结构Node,当根据hash计算数组中的索引值位置已经有值且不是同一个,则以索引位置节点为头节点,后来节点为尾节点

3.1.3 双链表-红黑树

static class LinkedHashMapEntry<K,V> extends HashMap.Node<K,V> {
        LinkedHashMapEntry<K,V> before, after;  // 在hashMap中并没有使用这两个节点信息
        LinkedHashMapEntry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }
复制代码
static final class TreeNode<K,V> extends LinkedHashMap.LinkedHashMapEntry<K,V> {
        TreeNode<K,V> parent;
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;
        boolean red;
        
        ............ // 省略方法代码
    }
复制代码

红黑树-双链表结构,继承自LinkedHashMapEntry,LinkedHashMapEntry又继承了Node节点;红黑树节点是单链表节点的子子类;含有前/后驱节点,左右孩子节点,父节点,以及颜色信息;前/后驱节点作为双链表结构,左右孩子节点-父节点-颜色作为红黑树结构

主要方法有:

  • root() 查找红黑树根节点,通过根节点的父节点为空,其它节点的父节点不空特性来查找
  • moveRootToFront() 把指定节点为根节点;如果当前hash所对应的索引节点为指定节点,则不需要任何处理,否则,指定节点为根节点,放在数组中hash对应索引位置,当前根节点为指定节点下个节点,指定节点前/后驱节点相互连接
  • find() 根据搜索树特性,来进行查找(搜索树,节点左树的值 <= 节点的值 < 节点右树的值)
  • getTreeNode() 从根节点,以key值来查找
  • tieBreakOrder() 比较物理地址,物理地址小于等于 算作小于,其它算大于
  • treeify() 单链表结构转换双链表-红黑树结构;首先按照搜索树,进行插入,每插入一个节点后均进行红黑树规则处理,使其成为一个红黑树
  • untreeify() 双链表-红黑树退化为单链表结构;以双链表前后驱动节点来连接为一个单链表
  • putTreeVal() 插入一个几点:根据搜索树特性插入,进行红黑树规则调整,并重新设置调整后的hash对应索引位置的节点值;父节点后驱为当前加入子节点,子节点后驱为父节点之前的后驱节点,保证了双链表连接整个红黑树
  • removeTreeNode() 删除当前节点
  1. 在双链表中去除当前节点,并连接前后驱动节点
  2. 如果删除点击是根节点,则结束流程;
  3. 重新计算根节点;并根据根节点的孩子节点情况判断是否要退化为单链表结构,则结束流程,满足a,b任意一条即退化:a) 树结构不超过两层,b)树的层深为3层,根节点的左孩子为空,或者根节点的左孩子的做孩子为空
  4. 如果删除节点没有孩子节点,则断了和父节点索引,返回
  5. 如果左右孩子存在空节点,则其不空节点替换当前删除节点,红黑树中去掉删除节点
  6. 若果左右孩子均不为空,以右孩子的最左节点替换当前节点,并调换红黑树中的位置信息,也就是左右孩子,父孩子信息,颜色;这时,删除节点无左孩子,则使其右子节点替换当前删除节点;也就是,先找到大于删除节点的最小值,互相替换位置信息,然后在使用替换后位置(其无左孩子节点)的右孩子节点替换互换后删除节点的位置
  7. 删除后调整红黑树;a) 如果互换位置信息后的删除节点为红色,因为其无左孩子或者有孩子,所以其没有任何孩子节点,无需调整;b) 如果为黑色节点,那么其存在左孩子或者右还在,其为红色节点
  • split() 扩容后,对当前树分成两个单链表:按照节点个数,小于等于6退化为单链表,否则重新树化;原理:hashmap的大小为2的n次方,每次扩容扩大2倍;所以之前hash对应同一个索引,现在也就在当前大小最高位存在0或者1的区别;也就是假设之前容器大小为n,索引为index,那么扩容后,index所有的链表数据/红黑树-双链表数据,全部都会对应到index 、index+n的位置
  • rotateLeft() 左旋方法,指定节点为p,则p的右孩子做p的父节点,p作为p的右孩子节点的左孩子节点,p的右孩子的左节点作为p的右节点
  • rotateRight() 右旋方法,指定节点为p,则p的左孩子节点做p的父节点,p作为p的左孩子的右孩子节点,p的左孩子的右孩子节点作为p的左节点
  • balanceDeletion() 删除数据后调整;此时删除的节点是黑色节点;第二个参数为已替换节点;执行for循环
  1. 若为红色或者根节点,直接染黑,返回;否则按照替换节点是左孩子或者右孩子来处理
  2. 为左孩子节点:此时是黑色,右孩子为空,则替换节点的父节点重置为替换节点,重新循环
  3. 为左孩子节点:右孩子是红色节点,则右孩子置为黑色,父节点置为红色,进行右旋
  4. 为左孩子节点:右孩子为黑色
    a) 右孩子的左右孩子都是黑色节点或者空节点,则父节点重置为已替换节点,重新循环
    b) 右孩子的左孩子为红色,则右孩子置为红色,右孩子的左孩子置为灰色,右旋,然后父节点置为黑色,左旋
    c)右孩子的左孩子为黑色,父节点置为黑色,左旋

【5.为右孩子 和左孩子旋转相反类似】

  • balanceInsertion() 插入数据调整,插入节点,for循环处理
  1. 默认插入颜色为红色
  2. 若为根节点,染黑结束
  3. 若父节点为黑色,或者父节点的父节点为空,则返回
  4. 父节点为红色,且为父父节点的左节点
    a) 父节点的兄弟节点也为红色,父节点,父节点兄弟节点均燃黑色,父父节点燃红色,以父父节点为插入节点重新循环
    b) 如果父节点兄弟节点为黑色,插入节点为父节点的右孩子,则以父节点左旋,调整节点(之前父节点变为左孩子,并成为插入节点,之前插入节点变为父节点);父节点置为黑色,父父节点置为红色,以父父节点右旋
    【5. 父父节点为右节点,相反类似】

3.2 扩容原理

容器大小为2的n次方,扩容因子为m;默认n = 16, m = 0.75:存在3种情况下会扩容

  • 容器内数组未初始化或者大小为0
  • 此时已存储元素个数大于n * m 会扩容
  • 容器个数小于64,某个位置的单链表长度大于等于7时,这时不直接转换为树结构,而是进行扩容
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) {
            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;
        @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. 首先计算扩容后容器大小:a) 已经存储过元素:之前容器大小不为0,则扩大2倍,threshold也扩大2倍,如果容器大小是 1 << 30 则直接设置为 1 << 31 -1; b)第一次加入元素:通过构造器已经传入的了大小,这时还未给数组尺寸定值,直接使用threshold, c) 第一次加入元素:初始化未提供大小,则赋值默认16,threshold 为16 * 扩容因子
  2. 检查threshold是否被重置,也就是1中b的情况,threshold = 新的容器大小 * 扩容因子
  3. for 循环从第0个位置(i)开始,根据hash值重新计算位置: a) 索引位置元素为空,则不处理, b) 索引位置不为空,其没有后驱节点,则计算新位置,直接赋值当前值,c) 索引位置不为空,其存在后驱节点,若后驱节点为单链表结构,则分成两个单链表,一个放在当前位置,一个放在i, 一个放在i + 原有容器处, d) 索引位置不为空,其存在后驱节点,若后驱节点为双链表-红黑树,则分成两个双链表,并依据其尺寸是否小于等于6来进行处理,> 6 重新树化,否则退化为单链表

为什么可以分成两个链表呢

原因很简单,容器为2的倍数增加,则在同一个索引位置的节点 hash值在容器大小二进制数据1的位置以及左边不同,也就是扩容后,得到新的索引,只有和旧容器大小二进制仅有1的位置有0和1的区别,也就是旧的索引位置 或者旧的索引位置+旧的尺寸

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
    
    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;
    }
    
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

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

复制代码

从构造函数,可以看出,构造时,进行了延时处理,也就是未进行数据存储内存申请,只是计算了存储因子,或者使用threshold暂时记录了数组大小;tableSizeFor方法,通过把cap的第一为1的后面全部置为1,然后加1,达到大小为cap的最小的2的n次方数

3.3 插入

直接上源码和分析

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;
    }
复制代码
  1. 是否为第一次加入新元素,初始化容器(也是调用扩容方法)
  2. 如果加入key的hash值对应索引位置无数据,直接插入
  3. 如果key的hash值对应索引位置有数据,且节点为红黑树结构,则查看2节中关于红黑树插入的内容
  4. 如果key的hash值对应索引位置有数据,且节点为单链表结构,则进行for循环处理: a)链表存在数据,其key与当前物理地址相同或者key的equal比较相同,则重置数据返回, b) 若是已经到链表尾部,则新增节点,加入到尾部;如果加入后数据大小>= 7 则进行树化,查看2节中树化方法
  5. 尺寸+1,判断是否达到阈值,达到则进行扩容

3.4 获取元素

获取元素比较简单,以key的hash值找到索引位置,然后根据位置的节点特点来查找元素

  1. 节点为空,则无此元素
  2. 节点为红黑树节点,查看2章节中getTreeNode方法分析
  3. 节点为单链表,从头到尾进行比对,如果比对成功,则退出,否则返回null;比对依据:hash值相同且物理地址相同或者equal方法相同
public V get(Object key) {
        Node<K,V> e;
        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 && // 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;
    }
复制代码

3.5 删除方法

直接上分析,分析如下

public V remove(Object key) {
        Node<K,V> e;
        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 &&
                            ((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 ||
                                 (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;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }
复制代码
  1. 如果未加入过元素,则不处理
  2. 如果删除key的hash对应索引位置元素为空,则不处理
  3. 如果索引节点的key和要删除的key比对相同,则删除节点即为索引节点
  4. 索引节点后驱为空,则不需要处理
  5. 索引节点后驱不为空,则在链表或者红黑树中查找此节点
  6. 红黑树结构使用removeTreeNode删除元素,单链表,删除元素后,其前驱的后继为其后继;并大小减1

3.6 清空方法

所有索引位置置空,也即断开单链表或者双链表-红黑树的根节点,进而删除所有元素

public void clear() {
        Node<K,V>[] tab;
        modCount++;
        if ((tab = table) != null && size > 0) {
            size = 0;
            for (int i = 0; i < tab.length; ++i)
                tab[i] = null;
        }
    }
复制代码

4 原理总结

  1. 数据结构采用 数组+单链表+双链表-红黑树结构;hash值对应索引位置为链表根节点
  2. hash寻址机制,冲突采用单链表或者双链表-红黑树结构解决
  3. 2倍扩容机制,扩容后索引节点对应链表进行分为两个链表再进行处理,有点巧妙
  4. 扩容时机有三个:a)由于使用延时申请存储内存,所以在第一次加入元素时,b)大小小于64且需要树化时,c) 元素个数超过阈值时
  5. 树化依据:链表数据个数>= 7且容器大小小于64,场景:插入数据,扩容时重新树化;退化依据: 链表数据 <= 6,场景:删除数据,扩容时
  6. 比较大小,按照hash值相等且 物理地址相等或者equal方法相等

技术变化都很快,但基础技术、理论知识永远都是那些;作者希望在余后的生活中,对常用技术点进行基础知识分享;如果你觉得文章写的不错,请给与关注和点赞;如果文章存在错误,也请多多指教!

原文 

https://juejin.im/post/5f045b8df265da22e425dd64

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » HashMap不得不知道的那些事儿

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址