深度剖析HashMap一篇文章就够了

522 阅读7分钟

HashMap概述

HashMap 1.7及以前,底层数据结构使用 [数组+链表],1.8 后使用 [数组+链表/红黑树] ,使用数组存储元素是因为查找快,链表是为了解决哈希冲突存在的,而红黑树是为了解决链表中查询速度慢对链表进行优化的一种数据结构。HashMap 是非线程安全的,如果需要线程安全,使用 ConcurrentHashMap 或者 Collections.synchronizedMap() 包裹 HashMap 达到线程安全的目的。

用两张图清晰的表达 jdk 1.7 / 1.8 中 hashmap 的数据结构。【图片来自网络】

JDK 为何用 红黑树来优化 HashMap中的链表,有什么好处??且听我娓娓道来。

红黑树

在介绍红黑树之前,先介绍 [二叉查找树],又称:[二叉搜索树],[二叉排序树],一般用来优化链表。有如下特性:

  • 左子树上所有结点的值均小于或等于它的根结点的值
  • 右子树上所有结点的值均大于或等于它的根结点的值
  • 左、右子树也分别为二叉排序树

eg:要查找 10 这个元素,查找过程:

  • 9 < 10 (右节点)
  • 13 > 10 (左节点)
  • 11 > 10 (左节点)
  • 10 = 10 找到元素

二叉排序树 找到结果的最大次数就是 二叉树的高度,极端情况呢?如 元素分别为 [7,6,5,4,3,2,1],此时按照二叉排序树的特性,树会变成一条直线,也就成了线性查询,时间复杂度为 O(N)级别,为了优化这种问题,[ 红黑树 ] 出场了。

红黑树就是一种 自平衡的二叉查找树,自平衡的特性就是对 HashMap 中链表可能会很长的问题作出的优化。

红黑树是每个节点都带有颜色属性的二叉查找树,特性如下:

  • 节点是红色/黑色
  • 根节点一定是黑色
  • 每个叶节点(NIL节点、空节点)是黑色的
  • 每个红色节点的两个子节点都是黑色的(从每个叶子到根的所有路径上不能有两个连续的红色节点)
  • 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点

[一颗典型的红黑树]

如何向 红黑树 中插入一个节点呢?

eg:向上图中插入 14 节点元素,就不会破坏红黑树的特性。

如果插入元素 21 ,就会破坏掉红黑树的特性。

那红黑树是如何维护树的自平衡的??

红黑树通过"变色"和"旋转"维护红黑树的规则,旋转有分为"左旋转",“右旋转”。

旋转示例

1)将以下图进行左旋转

2)将以下图进行右旋转

源码分析

以下源码都来自 jdk1.8

默认值

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16, 默认初始化容量
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;	// 最小树化数组容量,转换为红黑树的最小数组长度为64

影响 HashMap 性能的两个因素

初始容量

  • 创建哈希表时的容量

负载系数

  • 衡量哈希表在自动增加容量之前的填充程度的容量,当哈希表中的数据数量超过 (负载因子 * 当前容量) 时,哈希表将被重建
  • eg:在不指定 HashMap 容量时,初始容量为 16,当此 map 数据量达到 12 时,哈希表将会扩容,重建。
public HashMap(int initialCapacity, float loadFactor) {}

put()

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 如果存储元素的table为空,则进行必要字段的初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        // 获取长度 16
        n = (tab = resize()).length;
    // 如果根据hash值获取的结点为空,则新建一个结点
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 如果新插入的结点和table中p结点的hash值,key值相同的话
        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 时,将链表转换为红黑树
                    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 重复时,覆盖旧值, onlyIfAbsent 为入参false
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            // 判断是否允许覆盖,并且value是否为空
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    // 记录修改 HashMap 内部结构的次数(映射次数或重新哈希的次数)
    ++modCount;
    // map 大小 > 临界值
    if (++size > threshold)
        // 将数组大小扩容,原来的2倍,并将原数组赋值到新数组,可能是链表,可能是红黑树
        resize();
    // 回调以允许LinkedHashMap后置操作
    afterNodeInsertion(evict);
    return null;
}

resize()

/**
 * 初始化或增加表的大小,如果表为空,根据初始容量分配。扩容表,2次幂
*/
final Node<K,V>[] resize() {
    // 获取旧元素数组的各种信息
    Node<K,V>[] oldTab = table;
    // 旧数组长度 
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 旧数组临界值
    int oldThr = threshold;
    // 定义新数组的长度及扩容的临界值
    int newCap, newThr = 0;
    // 如果原 table 不为空
    if (oldCap > 0) {
        // 如果数组长度达到最大值,修改临界值为最大值
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 扩容操作(2倍)
        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;	// 16
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 16 * 0.75 
    }
    // 临界值还为0,设置临界值
    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;
}

treeify

/**
* 将链表中每个值进行红黑树插入操作
*/
final void treeify(Node<K,V>[] tab) {
    TreeNode<K,V> root = null;
    for (TreeNode<K,V> x = this, next; x != null; x = next) {
        next = (TreeNode<K,V>)x.next;
        // 初始化Root
        x.left = x.right = null;
        if (root == null) {
            x.parent = null;
            x.red = false;
            root = x;
        }
        else {
            K k = x.key;
            int h = x.hash;
            Class<?> kc = null;
            for (TreeNode<K,V> p = root;;) {
                int dir, ph;
                K pk = p.key;
                if ((ph = p.hash) > h)
                    dir = -1;
                else if (ph < h)
                    dir = 1;
                else if ((kc == null &&
                          (kc = comparableClassFor(k)) == null) ||
                         (dir = compareComparables(kc, k, pk)) == 0)
                    dir = tieBreakOrder(k, pk);
                TreeNode<K,V> xp = p;
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    x.parent = xp;
                    if (dir <= 0)
                        xp.left = x;
                    else
                        xp.right = x;
                    // 平衡调节
                    root = balanceInsertion(root, x);
                    break;
                }
            }
        }
    }
    // 确保给定的根是根结点
    moveRootToFront(tab, root);
}

面试题

1、HashMap 为什么选用红黑树这种数据结构优化链表?

2、为什么默认初始容量为2次幂?不是2次幂会怎样?讲讲 HashMap 扰动函数?

3、HashMap 中链表转化为红黑树的条件?

4、HashMap为什么是非线程安全的?体现在哪些方面?

5、说说 Hashmap 中 put 是如何实现的?

6、平时使用 Hashmap 时会将什么类型的元素作为 key?


总结

以上是小编在学习过程中总结的一些内容,如有理解不到位的地方,还望各位大佬指出,不胜感激。