20.2 HashMap（集合底层源码解析）

1.2 Map体系

1.2.1 HashMap & Hashtable

1）底层实现和特点

HashMap和Hashtable底层都是由哈希表实现，HashMap和Hashtable的关系与ArrayList和Vector的关系是一样的。HashMap线程不安全，Hashtable线程安全。

特点：HashMap的key无序不可重复，value可以重复

2）哈希表的介绍

什么是哈希表？

哈希表是一种用于快速查询的数据结构，在精准定位方面性能非常的好（通过key找value），查找速度和元素的个数无关（理想状态，实际过程中，多少还是有点关系），时间复杂度为O（1）

优势：可以快速的通过key找到value。 快速定位、大数据去重、判断是否存在… 哈希表？？？

什么是哈希函数？

可以将任意类型的key转换成int类型下标

特点：
1、任何类型 -> int类型
2、同一个值 在 任何时候，转换的下标必须一样
3、转成的下标必须落在哈希表的有效范围之内

自己实现一个哈希函数？
实现：key.hashcode() % array.length

什么是哈希碰撞？（哈希冲突 - 重要）

两个元素（key-value）,通过哈希函数计算出同一个下标，如果key相同，则后面的元素value覆盖前面的元素value，如果key不同，则发生了所谓的哈希碰撞。哈希碰撞不是好事，而是因为不可避免。

**问题1：**哈希表是如何判断key是否相同的？

if (p.hash == hash &&
             ((k = p.key) == key || (key != null && key.equals(k))))

先判断两个key的hash值是否相同，如果相同，再判断两个元素的key是否相等（== 或者 equals）

**问题2：**哈希碰撞发生后该怎么办？

哈希冲突的解决

1、开发地址法 - 发生碰撞后，新的元素自动往后移位
2、链地址法 - 将发生碰撞的元素通过链表连接起来（优势，不占其他的桶，劣势，影响查询性能）

注意：JDK1.8之后，引入了链表 + 红黑树的方式解决哈希冲突

为什么要用链表 + 红黑树，而且是链表大于8的时候
最初链表还不是很长，所以可能 O(n) 和 O(log(n)) 的区别不大，但是如果链表越来越长，那么这种区别便会有所体现。所以为了提升查找性能，需要把链表转化为红黑树的形式。

哈希表的扩容

为什么哈希表要扩容？
随着添加元素越来越多，适当的扩容可以降低发生哈希碰撞概率。以及重新计算原来节点的桶位置，打散原来链表的长度，起到提高查询效率的作用。

扩容阈值：当元素个数达到扩容阈值之后，就会触发一次哈希表的扩容。
填充因子：扩容的元素比例，扩容阈值 = 哈希表容量 * 填充因子

3）红-黑树 - （简单介绍）

什么是红-黑树？

红-黑树是一种特殊的二叉搜索树，也是一种便于快速查询的数据结构，但是查询性能会比哈希表略低。

什么是二叉搜索树？

二叉树 -> 二叉搜索树。在二叉搜索树中，任何一个节点的所有左子节点都小于该节点，所有的右子节点都大于该节点，这种二叉树，就称之为二叉搜索树。

缺点：害怕树的失衡

红-黑树就是一个永远平衡的二叉搜索树

红黑规则

只要遵循了红黑规则的二叉搜索树就一定是平衡的
1、根节点一定是黑色
2、红色节点不能有红色的子节点（红红冲突）
3、从根节点触发，到任意一个叶子节点，经过的黑节点数量必须相同
4、新增的节点默认为红节点

红黑树的平衡手段

变色 + 旋转

4）HashMap源码解析 - JDK1.8

常用属性

/**
 * 哈希表的默认初始长度 - 16
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

/**
 * 哈希表的最大长度 - 2^30
 */
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * 默认填充因子 - 0.75
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
 * 链表长度到8时转成红黑树
 */
static final int TREEIFY_THRESHOLD = 8;

/**
 * 红黑树的个数到6时转成链表
 */
static final int UNTREEIFY_THRESHOLD = 6;

/**
 * 哈希表的元素达到64时，链表才会转红黑树
 */
static final int MIN_TREEIFY_CAPACITY = 64;

/**
底层哈希表
*/
transient Node<K,V>[] table;

/**
当前的拓展阈值，当元素个数达到这个值时，就触发扩容
*/
int threshold;

/**
当前的填充因子
*/
final float loadFactor;

哈希表中的节点元素

//哈希表的节点
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash; //当前节点的hash值，通过key计算而来
    final K key; //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;
    }
}

构造方法

/**
 * 无参构造
 */
public HashMap() {
    //设置当前的填充因子为默认的填充因子 0.75f
    this.loadFactor = DEFAULT_LOAD_FACTOR; 
}

/**
有参构造
参数1：初始化的哈希表的长度
参数2：填充因子
*/
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;
    
        //1 2 4 8 16 32 64 128 ......  
        //根据初始容量，计算离这个容量最近的2的N次方的结果值
        //设置给当前的扩容阈值
        this.threshold = tableSizeFor(initialCapacity);
}

注意：JDK1.8之后，哈希表的容量必须是2的N次方

添加元素（put）

/**
添加元素
参数4：false代表，key相同时，value覆盖，如果为true，表示value不覆盖
*/
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

/**
哈希函数
*/
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

/**
核心的添加元素的方法
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        //tab - 代表当前的哈希表
        //p - 代表当前key对应的哈希桶中的元素
        //n - 代表哈希表的长度
        //i - 代表key对应的哈希桶的下标
        Node<K,V>[] tab; Node<K,V> p; int n, i;
    
        //------------------第一次添加元素时触发-----------------------
		//判断哈希表是否为空，如果为空表示当前第一次添加元素
        if ((tab = table) == null || (n = tab.length) == 0)
            //如果哈希表还没有初始化，就调用resize方法初始化哈希表
            n = (tab = resize()).length;
    	//------------------第一次添加元素时触发-----------------------
    
        //任何一个数字 & n 结果一定是0 ~ n范围 
        //(n - 1) & hash 通过key的哈希值计算下标，赋值给i
        //从哈希表tab，下标为i的元素赋值给p
        //判断p是否为null
        if ((p = tab[i = (n - 1) & hash]) == null)
            //说明当前哈希桶为空，没有发生哈希碰撞
            //新建一个Node，将key，value等都保存到节点中
            //将新的节点放入桶i的位置
            tab[i] = newNode(hash, key, value, null);
        else {
            //桶i的位置不为空
            //e - 哈希碰撞的桶的第一个元素
            //k - 下标为i的哈希桶的第一个元素的key值
            Node<K,V> e; K k;
            //判断新增的key和p是否相同
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //如果相等 将p赋值给e
                e = p;
            else if (p instanceof TreeNode)
                //判断当前哈希桶中是否为红黑树
                //走红黑树的逻辑
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //哈希桶中是链表，并且发生了哈希碰撞
                //遍历当前的桶的链表
                for (int binCount = 0; ; ++binCount) {
                    //e一直指向p的下一个节点
                    if ((e = p.next) == null) {
                        //表示走到了最后一个节点，说明整个链表都没有发现相等的key
                        //创建一个新的节点，放入链表的尾端
                        p.next = newNode(hash, key, value, null);
                        //binCount - 循环的链表数量
                        //判断链表的长度是否达到转树的条件（有没有超过8）
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            //可能转红黑树？？？
                            treeifyBin(tab, hash);
                        break;
                    }
                    //判断节点e是否和添加的元素key相等
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            
            //当发现新增元素的key和某个元素的key相同时，e就不为null
            //并且e代表当前这个相同的元素
            if (e != null) { // existing mapping for key
                //获得旧的value
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    //value的覆盖
                    e.value = value;
                afterNodeAccess(e);
                //返回旧的value
                return oldValue;
            }
        }
        ++modCount;
        //判断当前元素数量，有没有超过扩容阈值
        if (++size > threshold)
            //进行扩容
            resize();
        afterNodeInsertion(evict);
        return null;
}

/**
链表转红黑树的方法
*/
 final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        //判断当前哈希表的容量有没有达到64
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            //如果没有达到64就进行一次扩容
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            //才进行链表转红黑树
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

resize()方法有两个作用：
1、初始化哈希表
2、哈希表扩容

思考：为什么要调用newNode方法创建节点，而不是直接new Node()?

扩容的方法（resize）

/**
1、哈希表的初始化
2、哈希表的扩容
*/
final Node<K,V>[] resize() {
    //oldTab - 代表旧的哈希表
    Node<K,V>[] oldTab = table;
    //oldCap - 代表旧的哈希表容量
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //oldThr - 代表旧的扩容阈值
    int oldThr = threshold;
    //新的容量、新的扩容阈值
    int newCap, newThr = 0;
    
    if (oldCap > 0) {
        //哈希表扩容走这里
        //旧的哈希表有值的，不是第一次调用
        if (oldCap >= MAXIMUM_CAPACITY) {
            //表示旧的哈希表容量已经是最大值，无法再扩容
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //设置新的哈希表容量 = 旧容量 * 2
        //设置新的扩展阈值 = 旧阈值 * 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 {  
        //第一次添加元素，哈希表还未初始化
        //设置默认容量16为新的哈希表容量
        newCap = DEFAULT_INITIAL_CAPACITY;
        //设置新的扩展阈值为12
        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;
    //创建一个新的哈希表
    //如果是第一个添加元素，则是创建一个长度为16的哈希表
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    //将新的哈希表赋值给全局变量
    table = newTab;
    
    //判断旧的哈希表是否为空
    //如果是第一次添加元素，旧的哈希表必然为null，哈希表的初始化就到此为止
    //如果不是第一次添加元素，那么还需要将旧的哈希表的元素重新计算下标移动到新的哈希表中
    if (oldTab != null) {
        //哈希表扩容走这里
        //循环旧的哈希表
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            //依次判断旧的哈希表中每个桶的元素是否null
            if ((e = oldTab[j]) != null) {
                //e代表旧的哈希表中桶j位置的元素
                oldTab[j] = null;
                //说明e只有一个元素，不是链表或者红黑树
                if (e.next == null)
                    //将元素e重新计算下标，赋值到新的哈希表的指定位置
                    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;
                        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;
}

TreeMap

1）底层实现和特点

特点：元素不可重复，有序（字典序）

底层实现：红-黑树。TreeMap的添加、查询的性能都会低于HashMap，除非真的需要Key有大小顺序，否则都应该使用HashMap。

问题：TreeMap如何判断两个key是否相同？ 比较器的返回值是否为0
作业：自行查询get(key)方法的源码