java集合图解源码系列【4】：从HashMap讲到红黑树和哈希表

大家好！我是未来村村长，就是那个“请你跟我这样做，我就跟你这样做！”的村长👨‍🌾！

||Data Structure||
未来村村长正推出一系列【Data Structure】文章，将从解读数据结构的角度上分析Java集合的源码。因为CSDN上的大多数描述java集合的文章，关注点在于其源码和方法，很少从对数据结构的讲解为切入点进行分析。以此为契机，未来村村长希望能从数据结构开始讲起，分析java集合是如何使用和如何实现的。

一、JDK1.7与JDK1.8

1、JDK1.7

​ 在JDK1.7时HashMap由数组+链表来实现，存放节点时要进行以下操作：

• 通过hash算法算出当前节点key的hash 值

• 通过计算出的hash值去调用indexFor方法计算当前对象应该存储在数组的几号位置

• 判断size是否已经达到了当前阈值，如果没有，继续；如果已经达到阈值，则先进行数组扩容，将数组长度扩容为原来的2倍。

2、JDK1.8

​ 在JDK1.8中HashMap底层是由“数组+链表+红黑树”组成。主要是为了提升在hash冲突严重时（链表过长）的查找性能，使用链表的查找性能是 O(n)，而使用红黑树是 O(logn)。

​ 链表和红黑树转换情况如下：

• 插入：默认情况下是使用链表节点，当同一个索引位置的节点在新增后达到9个（阈值8）后

  • 如果此时数组长度大于等于 64，则会触发链表节点转红黑树节点；
  • 如果数组长度小于64，则不会触发链表转红黑树，而是会进行扩容，因为此时的数据量还比较小。

• 移除：当同一个索引位置的节点在移除后达到 6 个，并且该索引位置的节点为红黑树节点，会触发红黑树节点转链表节点。

​ 在探究HashMap之前，我们先来看看其基础的数据结构如何构建的。

二、哈希表

​ 我们知道Hash表本质就是一个存放链表的数组，我们来实现一个基本的hash表。

1、节点定义

class Node<V>{
    int key;
    V value;
    Node<V> next;
    Node(int key,V value){
        this.key = key;
        this.value = value;
        this.next = null;
    }
    
    @Override//toString-方便后续打印
    public String toString() {
        return "Node{" +
                "key=" + key +
                ", value=" + value +
                ", next=" + next +
                '}';
    }
}

2、Hash算法

​ 我们这里简单写一个hash算法。

private int hash(int key) {
        while (key > this.size) {
            key = key % 7;
        }
        int hashValue = (int) key;
        return hashValue;
    }

3、基本属性和方法

class HashTable<V>{
    //定义一个数组
    Node[] hashArray = new Node[20];//定义初始大小
    //大小
    int size = 0;

4、插入

public void put(int key,V value){
        Node<V> newNode = new Node(key,value);
        //计算hash值
        int hashValue = hash(newNode.key);
        //找到对应的数组位置
        if(hashArray[hashValue] == null){
            hashArray[hashValue] = newNode;
        }
        else{
            Node<V> current = hashArray[hashValue];
            while(current!=null){
                current = current.next;
            }
            current = newNode;
        }
        size ++;
    }

​ 补充数组的扩容，在此处我们规定了hashtable中数组的大小，并且hash于其大小有关，当size过大时，我们可以考虑给hashArray进行扩容。我们规定，当size大于数组大小的2倍时进行扩容。

if(size>(hashArray.length*2)){
    Node hashArray = new hashArray[this.hassArray.length*2];
    for(int i = 0; i<hashArray;i++) hashArray[i] = this.hashArray[i];
}

5、打印

​ 我们可以将其打印一下。

public void print(){
        for(int i=0;i<hashArray.length;i++){
            if(hashArray[i]!=null){
                Node current = hashArray[i];
                while (current!=null){
                    System.out.println("第"+i+"个数组中：" + current);
                    current = current.next;
                }
            }
        }
}

6、删除

public Node<V> remove(int key){
    int hashValue = hash(key);//通过hash函数找到对应的位置
    if(hashArray[hashValue]==null){
        return null;
    }//判断是否正确
    else{
        Node current = null;
        if(hashArray[hashValue].key = key){
        	current = hashArray[hashValue];
            hashArray[hashValue] = current.next;
             return current;
        }else{
            current = hashArray[hashValue];
        	while(current!=null && current.next.key != key){
                current = current.next;
            }
            current.next = current.next.next;
        }
    }
}

​ 综上我们就实现了一个哈希表，代码还有点小问题，希望有人能帮我找到问题所在。

三、红黑树

​ java集合图解源码系列【2】：从二叉树讲到TreeMap，一篇搞明白树的数据结构，我们摘取这篇文章的概念部分进行复习。

1、红黑树的定义

• 根节点是黑色，其余节点要么黑色要么红色
• 每个红色节点必须有两个黑色子节点
• 所有叶子节点皆为黑色
• 从任一节点到其每个叶子节点的所有简单路径上的黑色节点数量相同
• 插入的新节点为红色

2、红黑树的加入后调整

​ 调整的话，是因为插入新节点是会破坏红黑树的结构，所以需要进行调整。有以下五种情况：

（1）无需调整

​ 当父节点为黑色时，插入子节点，对于插入的子节点我们将其默认的black改为red。

（2）变色

​ 当父节点和叔父节点都为红色时

（3）旋转+变色

【蓝色代表祖父节点，黄色代表父节点】

A:左左型——父节点为红色左节点，叔父节点为黑色（或NULL），插入左节点

**A处理：**将其祖父节点进行右旋操作，然后进行变色。

B:左右型——父节点为红色左节点，叔父节点为黑色，插入右节点

**B处理：**将其父节点进行左旋，叔父节点进行右旋

C:右右型——同理但相反，类推即可

D:右左型——同理但相反，类推即可

（PS：以上图片大小不一致，我看着也很难受，各位点开再看吧）

3、二叉树的删除后调整

​ 删除后调整其实同理，我们只需要按照二叉排序树的定义去调整删除的节点，然后对以上的结构情况对删除后的红黑树进行调整即可。被删结点具有以下三种情况，我们可以在删除后对其进行结构性调整：

• 被删结点是叶结点（左、右子树都空 ）：只需要将其双亲节点指向他的节点赋值为null即可。
• 被删结点只有1个孩子结点 （左子树空或右子树空）：只需要将其双亲节点指向他的节点直接指向其被删除节点的孩子节点即可
• 被删结点有2个孩子结点（左、右子树都不空）：若直接选择一个子节点替换被删除的节点，可能会导致其不满足排序二叉树的属性，我们可以选择其左子树最大的的节点或右子树最小的节点来替换该节点。

四、HashMap

参考&摘抄：Ybb_studyRecord：关于HashMap面试这一篇足够了

1、源码初探

（1）基本属性

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {

    private static final long serialVersionUID = 362498820763181265L;
    
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    //最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;
	//默认负载因子为0.75
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
	//链表转红黑树阈值，节点数为9时链表转换为红黑树
    static final int TREEIFY_THRESHOLD = 8;
	//红黑树转链表阈值，节点数为6时红黑树转换为链表
    static final int UNTREEIFY_THRESHOLD = 6;
	//只有当table长度超过64时，才进行红黑树的转换
    static final int MIN_TREEIFY_CAPACITY = 64;
}

初始化容量为什么必须是 2 的 n 次幂：

• 因为其hash算法实际就是取模，使用 hash & (length - 1)，而实际上 hash % length 等于 hash & ( length - 1) ,所以前提必须是 length 是 2 的 n 次幂。
• 如果数组长度不是2的次幂,计算出的索引特别容易相同,及其容易发生hash碰撞,导致其余数组空间很大程度上并没有存储数据,链表或者红黑树过长,效率降低.

为什么Map桶中结点个数超过 8 才转为红黑树:

• 因为树节点所占空间是普通节点的两倍，所以只有当节点足够多的时候，才会使用树节点。说白了就是空间和时间的权衡。
• 链表中的节点遵循泊松分布，而且根据统计，链表中节点数是8的概率已经接近千分之一，而且此时链表的性能已经很差了。所以在这种比较罕见和极端的情况下，才会把链表转变为红黑树。因为链表转换为红黑树也是需要消耗性能的，特殊情况特殊处理，为了挽回性能，权衡之下，才使用红黑树，提高性能。

为什么负载因子设置为0.75，初始化临界值是12:

• loadFactor 越趋近于1，那么 数组中存放的数据(entry)也就越多，也就越密，也就是会让链表的长度增加。
• loadFactor 越小，也就是趋近于0，数组中存放的数据(entry)也就越少，也就越稀疏。

（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;
        }
//二、红黑树节点
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;
        TreeNode(int hash, K key, V val, Node<K,V> next) {
            super(hash, key, val, next);
        }
}

（3）哈希算法

先拿到key的hashCode值,将hashCode的高16位参与运算。

• n 表示数组初始化的长度是 16。
• &（按位与运算）：运算规则：相同的二进制数位上，都是 1 的时候，结果为 1，否则为0。
• ^（按位异或运算）：运算规则：相同的二进制数位上，数字相同，结果为 0，不同为 1。

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

​ 高 16bit 不变，低 16bit 和高 16bit 做了一个异或（得到的 hashCode 转化为 32 位二进制，前 16 位和后 16 位,低 16bit 和高 16bit 做了一个异或）。

​ 如果当 n 即数组长度很小，假设是 16 的话，那么 n - 1 即为 1111(15的二进制表示) ，这样的值和 hashCode 直接做按位与操作，实际上只使用了哈希值的后 4 位。如果当哈希值的高位变化很大，低位变化很小，这样就很容易造成哈希冲突了，所以这里把高低位都利用起来，从而解决了这个问题。

（4）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;
    // 校验table是否为空或者length等于0，如果是则调用resize方法进行初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 通过hash值计算索引位置，将该索引位置的头节点赋值给p，如果p为空则直接在该索引位置新增一个节点即可
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        // table表该索引位置不为空，则进行查找
        Node<K,V> e; K k;
        // 判断p节点的key和hash值是否跟传入的相等，如果相等, 则p节点即为要查找的目标节点，将p节点赋值给e节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //判断p节点是否为TreeNode, 如果是则调用红黑树的putTreeVal方法查找目标节点
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //走到这代表p节点为普通链表节点，则调用普通的链表方法进行查找，使用binCount统计链表的节点数
            for (int binCount = 0; ; ++binCount) {
                //如果p的next节点为空时，则代表找不到目标节点，则新增一个节点并插入链表尾部
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //校验节点数是否超过8个，如果超过则调用treeifyBin方法将链表节点转为红黑树节点，
                    // 减一是因为循环是从p节点的下一个节点开始的
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                    break;
                }
                //如果e节点存在hash值和key值都与传入的相同，则e节点即为目标节点，跳出循环
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;  // 将p指向下一个节点
            }
        }
        //如果e节点不为空，则代表目标节点存在，使用传入的value覆盖该节点的value，并返回oldValue
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e); // 用于LinkedHashMap
            return oldValue;
        }
    }
    ++modCount;
    //如果插入节点后节点数超过阈值，则调用resize方法进行扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);  // 用于LinkedHashMap
    return null;
}

（5）扩容方法

final Node<K,V>[] resize() {
    // 得到当前数组
    Node<K,V>[] oldTab = table;
    // 如果当前数组等于null长度返回0，否则返回当前数组的长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //当前阀值点 默认是12(16*0.75)
    int oldThr = threshold;
    int newCap, newThr = 0;
    // 如果老的数组长度大于0
    // 开始计算扩容后的大小
    if (oldCap > 0) {
        // 超过最大值就不再扩充了，就只好随你碰撞去吧
        if (oldCap >= MAXIMUM_CAPACITY) {
            // 修改阈值为int的最大值
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        /*
        	没超过最大值，就扩充为原来的2倍
        	1) (newCap = oldCap << 1) < MAXIMUM_CAPACITY 扩大到2倍之后容量要小于最大容量
        	2）oldCap >= DEFAULT_INITIAL_CAPACITY 原数组长度大于等于数组初始化长度16
        */
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            // 阈值扩大一倍
            newThr = oldThr << 1; // double threshold
    }
    // 老阈值点大于0 直接赋值
    else if (oldThr > 0) // 老阈值赋值给新的数组长度
        newCap = oldThr;
    else { // 直接使用默认值
        newCap = DEFAULT_INITIAL_CAPACITY;//16
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 计算新的resize最大上限
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    // 新的阀值 默认原来是12 乘以2之后变为24
    threshold = newThr;
    // 创建新的哈希表
    @SuppressWarnings({"rawtypes","unchecked"})
    //newCap是新的数组长度--》32
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    // 判断旧数组是否等于空
    if (oldTab != null) {
        // 把每个bucket都移动到新的buckets中
        // 遍历旧的哈希表的每个桶，重新计算桶里元素的新位置
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                // 原来的数据赋值为null 便于GC回收
                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 { // 采用链表处理冲突
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    // 通过上述讲解的原理来计算结点的新位置
                    do {
                        // 原索引
                        next = e.next;
                     	// 这里来判断如果等于true e这个结点在resize之后不需要移动位置
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        // 原索引+oldCap
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 原索引放到bucket里
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 原索引+oldCap放到bucket里
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

​ 数组扩容：当HashMap中的元素个数超过数组大小(数组长度)*loadFactor(负载因子)时，就会进行数组扩容，loadFactor的默认值(DEFAULT_LOAD_FACTOR)是0.75,这是一个折中的取值。

​ 例：数组大小为16，那么当HashMap中的元素个数超过16×0.75=12(这个值就是阈值或者边界值threshold值)的时候，就把数组的大小扩展为2×16=32

​ 当HashMap中的其中一个链表的对象个数如果达到了8个，此时如果数组长度没有达到64，那么HashMap会先扩容解决，如果已经达到了64，那么这个链表会变成红黑树，结点类型由Node变成TreeNode类型。

（6）查找方法

若为树，则在树中通过key.equals(k)查找：O(logn)。

若为链表，则在链表中通过key.equals(k)查找：O(n)。

 final TreeNode<K,V> getTreeNode(int h, Object k) {
            return ((parent != null) ? root() : this).find(h, k, null);
 }
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
    TreeNode<K,V> p = this;
    do {
        int ph, dir; K pk;
        TreeNode<K,V> pl = p.left, pr = p.right, q;
        if ((ph = p.hash) > h)
            p = pl;
        else if (ph < h)
            p = pr;
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            return p; // 找到之后直接返回
        else if (pl == null)
            p = pr;
        else if (pr == null)
            p = pl;
        else if ((kc != null ||
                  (kc = comparableClassFor(k)) != null) &&
                 (dir = compareComparables(kc, k, pk)) != 0)
            p = (dir < 0) ? pl : pr;
        // 递归查找
        else if ((q = pr.find(h, k, kc)) != null)
            return q;
        else
            p = pl;
    } while (p != null);
    return null;
}

2、补充

以下内容来自各大大佬关于hashMap的面试题文章。

（1）工作原理

① put

• 用hash(K)方法计算K的hash值,然后结合数组长度,计算得数组下标;
• 调整数组大小(当容器中的元素个数大于capacity*loadfactor时,容器会进行扩容resize为2n);
• 如果K的hash值在HashMap中不存在,则执行插入,若存在,则发生碰撞;
• 如果K的hash值在HashMap中存在,且它们两者equals返回true,则更新键值对;
• 如果K的hash值在HashMap中存在,且它们两者equals返回false,则插入链表的尾部(尾插法)或者红黑树中(树的添加方式)。

注意:数组长度超过64且碰撞导致链表大于TREEIFY_THRESHOLD=8时,才把链表转换成红黑树。（如果 size 大于阈值 threshold，则进行扩容）

② get

• 调用hash(K)方法(计算K的hash值)从而获取该键值所在链表的数组下标;
• 顺序遍历链表,equals()方法查找相同Node链表中K值对应的V值。

（2）与其他集合结构区别

集合类	Key	Value	Super	说明
HashTable	不允许为null	不允许为null	Dictionary	线程安全（synchronization）
ConcurrentHashMap	不允许为null	不允许为null	AbstractMap	CAS锁分段
TreeMap	不允许为null	允许为null	AbstractMap	不安全
HashMap	允许为null	允许为null	AbstractMap	不安全

HashMap线程不安全：

• 两个线程执行put()操作时，可能导致数据覆盖。
• 扩容时导致死循环：只有 JDK7 及以前的版本会存在死循环现象，在 JDK8 中，resize()方式已经做了调整，使用两队链表，且都是使用的尾插法，及时多线程下，也顶多是从头结点再做一次尾插法，不会造成死循环。