【集合】HashMap(JDK8)

一、概述

Map接口在java中是用来存储键值对的,其中HashMap的使用最为频繁。和前朝遗老HashTable相比HashMap是非线程安全的类,且可以插入null的key和value。在JDK8中,HashMap=数组+链表+红黑树。下面是一些关键的参数和数据结构:

  1. table:HashMap用来存储元素的数组,数组的元素为键值对节点(Node),每个数组元素又称之为桶(bucket)
  2. capacity:数组容量,即桶的数量,即table.length,必须为2的n次方(计算数组位置时更有效率),默认16
  3. size:HashMap中所有的键值对的数量,包括数组中的,链表中的,树中的。
  4. loadFactor:负载因子,默认0.75,HashMap扩容时的一个参数,越低越容易触发扩容消耗空间;越高越容易哈希冲突,这样会生成链表或红黑树,插入查询时更消耗时间。所以0.75是对空间和时间效率的一个平衡选择。
  5. threshold:table的扩容阈值,当size大于这个值后HashMap进行resize。等于capacity*loadFactor,默认16*0.75=12
  6. TREEIFY_THRESHOLD:树化阈值(默认为8),当链表长度大于等于该值时,链表转换为红黑树

二、 源码分析

由于红黑树规则较为复杂,源码也非常晦涩,所以涉及到红黑树部分的分析就先一笔带过。

1.初始化

HashMap的初始化采用了懒加载的方式,换句话说就是new出HashMap的时候并没有将table数组创建出来而是仅仅设置了一些参数。

// java.util.HashMap
// 三种构造方式

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

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

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;
    // 传入的initialCapacity可能不是2的n次方,所以需要处理
    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;
}

当我们用指定容量的方式来构造HashMap时,有可能会出现传入的参数不是2的n次方,而这并不符合源码要求,如果说直接抛出非法参数异常则对调用者不太友好,因为这只是HashMap实现的特殊规则而已。所以源码使用了tableSizeFor方法来找到大于等于initialCapacity但又是2次幂的数值。光看源码可能根本无法知道它的功能,所以下面举个例子实例化一下。
初始化

2.添加键值对

我们常用put方法来添加键值对,这个方法实际上是将key的hashcode和存储位置关联起来。

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

static final int hash(Object key) {
    int h;
    // 将key的hashcode高16位和低16位进行异或运算
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}   
 
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 若HashMap未初始化,即第一次put时,则构造一个table出来
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 根据key的hash值计算出在数组中将要插入的位置,同时将p指针指向该位置。若该位置为空,则将该键值对放在这个位置上
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 若该位置不为空,即出现了位置冲突的情况(当然也不完全是哈希值相同导致的,也有可能是与运算得出的下标恰好相同)
    else {
        Node<K,V> e; K k;
        // 若占据该位置的key和待插入的key相同,即位置冲突是由于key相同导致的(通过判断两者key的哈希值是否相同以及两者key的地址是否相同或者是否equal),将指针e指向该位置节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 若key不相同,且p所指向的bucket是一个树结点,则插入一个树结点,并将指针e指向该结点
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        // 若key不相同,且p所指向的bucket是一个链表结点,则遍历该链表(移动e、p指针)
        else {
            for (int binCount = 0; ; ++binCount) {
            	//  移动e指针,直到遍历到链表尾部
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 当链表长度大于等于8时,且table长度大于64时,将链表树化
                    if (binCount >= TREEIFY_THRESHOLD - 1) 
                        treeifyBin(tab, hash);
                    break;
                }
                // 在链表中出现key相同的情况
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;               
                p = e;  // 移动p指针
            }
        }
        // e不为空的场景只有一种那就是出现了key相同的情况,此时e指向的节点就是相同key的节点,需要用新value替换旧value
        if (e != null) { 
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;           
            afterNodeAccess(e);  // 一个空的钩子方法
            return oldValue;
        }
    }
    ++modCount;
    // size加一,若超出阈值则扩容两倍(保证数组长度是2的n次方)
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

先从上述源码中看下关于哈希运算的操作。在put元素时,元素位置会根据key的hashcode经过一系列位运算得出的。它首先会将key的hashCode的高16位和低16位进行异或运算。然后再将这个值和(table.length-1)进行与运算就可以得出数组位置下标。

为什么高低位需要进行异或运算而不是直接采用key的hashcode呢?根本原因还是由于需要将元素均匀分散在table中,试想一下有两个node,他们key的hashcode的低位是相同的但是高位相差较大,若直接将hashcode进行与运算则在table长度较小的情况下就会出现位置冲突,从而形成链表或者红黑树。反之将高位参与进来,很可能位置冲突都不会发生了。

说到位置冲突就不得不提一个老生长谈的问题:为什么重写了equals就必须重写hashcode? 源码就说明了一切:当你自定义equals方法时是不希望对象以地址来比较是否相同,若不重写hashcode将两个对象放入HashMap后它们计算出的数组下标大概率不会相同,这样就失去了equals的判断机会if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))),从而两个相同的对象被存储了两次,这与你的初衷是违背的。

此外与运算的操作也印证了table的长度为什么需要是2的n次方。当table的长度是2的n次方时,table.length-1用二进制比特位就能形成一个掩码:高位(32-n)个0低位n个1。用这个掩码和hash进行与运算后得出的结果必在[0,2^n-1]的范围之内, 这样就不会出现数组越界的情况。取模%也可以起到同样的效果,但是位运算是效率最高的方式。
哈希碰撞

3.扩容机制

put元素时HashMap会自动初始化或者判断size是否到达阈值而进行扩容,本质上是重新new了一个容量更大的数组来存储元素。

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    // table为null的情况下,将容量(或者说table长度)设为0
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    // 当前table的长度大于0
    if (oldCap > 0) {
    	// 当前table的长度已达到最大值
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // table长度未到达最大值,长度和阈值扩容两倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; 
    }
    // 当前table的长度等于0,且table扩容阈值大于0。这种情况只出现在调用了构造方法HashMap(int initialCapacity, float loadFactor),table长度被置于threshold成员变量中
    else if (oldThr > 0) 
        newCap = oldThr;
    else {   // 当前table长度等于0,且扩容阈值等于0,即需要初始化
        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;
	// 构造一个新容量的数组
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    
    // 为空的情况是初始化的场景;不为空的情况才是扩容的情况,需要迁移node
    if (oldTab != null) {
    	// 遍历数组buckets
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            // 当前数组元素不为空
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                // 如果当前bucket没有形成链表,则根据hash重新计算新数组位置,并插入
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                // 当前bucket是一个树结点的情况
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // 当前bucket形成链表的情况,有可能需要拆分成两个链表
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        // 新增掩码所对应的bit是否为0
                        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) {
                    	// 尾部节点的next指针一定要指向null否则可能指向另一个链表节点
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 若高位置链表不为空,则将数组下标加上原数组长度插入新数组
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

扩容的这段源码中,确定新容量新阈值都比较容易理解,比较让人难以读懂的部分是老数组元素向新数组迁移的代码,尤其是链表的迁移。

链表迁移前,源码先定义了两组新的链表,一个是low一个是high。数组扩容后,节点元素位置只会发生两种情况:(1)要么下标保持不变 (2)要么在原来的下标值上加上原数组长度。所以low代表的是原下标位置的链表,high代表着新下标的链表,high也代表了这个下标值比原下标值要大。下面通过一个例子说明为什么增加的是原数组长度。
扩容
那么怎么才能知道下标发生了变化呢?重新计算hash当然可以,但是通过上述例子看出来只要新增掩码所对应的那个bit位是1就会发生变化否则就不变。所以可以用一个bit位的比较进行更快速的判断:(e.hash & oldCap) == 0
比特判断

4.获取键值对

获取键值对主要是根据key的hash值去查找节点所在位置,有可能节点在数组中,在链表中,在红黑树中,也有可能根本不存在。

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;
    /*三种情况往下执行,否则直接返回null
    (1)table不为空
    (2)table的容量大于零
    (3)待删除的key存在于map中
	*/
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 节点就是数组bucket
        if (first.hash == hash &&
            ((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;
}

5.删除键值对

删除键值对的逻辑和获取键值对的逻辑相类似,只不过是找到节点后进行了删除的操作。

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;
    /*三种情况往下执行,否则直接返回null
    (1)table不为空
    (2)table的容量大于零
    (3)待删除的key存在于map中
	*/   
    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;
        // 待删除的节点就是数组bucket,指针node指向该节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        // 待删除的节点存在于链表或红黑树中
        else if ((e = p.next) != null) {
        	// 节点在红黑树中,指针node指向该节点
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            // 节点在链表中,指针node指向该节点
            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);
            }
        }
        // 待删除节点node存在,且判断是否需要匹配value
        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);
            // 若节点是数组元素,则将后继结点(也有可能是null)前移到bucket中
            else if (node == p)
                tab[index] = node.next;
            // 若节点处于链表中,则前驱节点的指针指向删除节点的后继节点(也有可能是null)
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

三、参考

Java 8系列之重新认识HashMap

带你走进Java集合之HashMap

©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页