【java基础】HashMap源码解析

基础说明

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。

HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

下面是HashMap的类图

在HashMap里面，我们存储的每一个节点都是一个Node

    /**
     * Basic hash bin node, used for most entries.  (See below for
     * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
     */
    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;
        }
    }

对于HashMap，这篇文章不会对hash算法还有红黑树的原理进行说明，这个是属于数据结构的知识！！！

在开始了解HashMap源码前，先对HashMap的几个重要成员属性进行说明

    /**
     * The table, initialized on first use, and resized as
     * necessary. When allocated, length is always a power of two.
     * (We also tolerate length zero in some operations to allow
     * bootstrapping mechanics that are currently not needed.)
     */
    transient Node<K,V>[] table;

table就是用来存储元素的

    /**
     * The number of key-value mappings contained in this map.
     */
    transient int size;

size表示元素个数

    /**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

上面几个是关于table容量的一些属性

    /**
     * The bin count threshold for using a tree rather than list for a
     * bin.  Bins are converted to trees when adding an element to a
     * bin with at least this many nodes. The value must be greater
     * than 2 and should be at least 8 to mesh with assumptions in
     * tree removal about conversion back to plain bins upon
     * shrinkage.
     */
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * The bin count threshold for untreeifying a (split) bin during a
     * resize operation. Should be less than TREEIFY_THRESHOLD, and at
     * most 6 to mesh with shrinkage detection under removal.
     */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * The smallest table capacity for which bins may be treeified.
     * (Otherwise the table is resized if too many nodes in a bin.)
     * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
     * between resizing and treeification thresholds.
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

上面这些是关于是否树形化的一些属性

构造器

在HashMap中有3个构造器，分别如下

无参构造器

指定初始容量

指定初始容量和负载因子

通过Map创建

对于HashMap，一般都是使用无参构造器。对于初始容量，默认值就是16，对于负载因子，默认值就是0.75。

负载因子的作用就是判断table是否需要扩容了，如果table的容量达到了 当前容量*负载因子，那么就会进行扩容

put方法（无扩容，无冲突）

现在我们就来开始debug，下面就是要进行debug的代码

    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        for (int i = 0; i < 20; i++) {
            hashMap.put(i, "100");
        }
    }

对于debug，我们主要是看过程，一定不要过分在意细节，不然就绕进去了。下面就开始debug了

首先看看创建HashMap后有什么

可以发现创建就是设置了一些负载因子

然后进入put方法

该方法首先会计算传入k的hash值，对于hash算法，这里不做说明，请参考数据结构，下面就是hash方法的内容

计算完hash后，进入putVal方法

这个if就是判断当前table是否为null，显然是的，于是就进入到resize方法。resize方法内容很多，这里我不会说明每一条语句，挑重要的进行说明。在这之前，我们应当看一下该方法的注释

    /**
     * Initializes or doubles table size.  If null, allocates in
     * accord with initial capacity target held in field threshold.
     * Otherwise, because we are using power-of-two expansion, the
     * elements from each bin must either stay at same index, or move
     * with a power of two offset in the new table.
     *
     * @return the table
     */

开始debug

继续往下面走

上面的判断完成后就开始真正创建数组了

然后赋值，对于下面的if判断，其实就是将oldTab的值复制过来，由于oldTab为null，所以这个方法就结束了,这个方法结束之后，table就已经初始化了，大小为16

继续debug

这条语句就是判断指定通过hash算出来的索引位置是否已经存放了值，显然没有，所以就会将其设置到指定位置

继续往下面走，可以看见一个if语句

这个就是用来判断是否需要扩容的，threshold就是当前容量*负载因子，这里的threshold就是12

继续往下走，方法结束

下面就是添加完一个元素后的HashMap信息

---

put方法（无冲突，有扩容）

我们通过上面的学习应该知道了当table数组使用3/4的时候就会扩容了，下面来具体看一下流程

    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        for (int i = 0; i < 20; i++) {
            hashMap.put(i, "100");
        }
    }

还是这个代码，我们使用条件debug，看看i==12的时候是如何进行扩容的

由于大部分内容都是和一般情况一样的，所以我就直接跳到关键部分

当i=12的时候，++size会>threshold，所以会执行resize方法。resize方法前面部分也是一样的，我也是直接跳到关键部分

由于我们的table没有发生冲突，在这个循环里面 e.next==null 永远成立

复制完成之后就会返回新table，大小为32，threshold会更新为24

对于一般情况下的扩容，下面的条件基本都会成立，也就是threshold和容量都会翻倍

---

put方法（有冲突，无树化）

上面我们都是介绍的无hash冲突的情况，现在就来debug下出现hash冲突的情况

public class FixHashCat {

    @Override
    public int hashCode() {
        return 12345678;
    }
}

上面的FixHashCat重写了hashCode，使之成为固定值，这样方便debug

    public static void main(String[] args) {
        HashMap<FixHashCat, String> hashMap = new HashMap<>();

        hashMap.put(new FixHashCat(), "1");
        hashMap.put(new FixHashCat(), "2");
    }

上面的第二个put肯定就会产生hash冲突，下面就来看一下流程吧

对于重复的步骤我就跳过了，现在还是会进入putVal方法

由于我们没有重写equals方法，当前也没有树化，所以会进行如else语句

对于是否树化，链表的数量要大于等于7才行，加上新加入的那个，bitCount又是从0开始的，也就是当链表个数达到9个就会进行树化

由于我们添加后链表长度都才为2，所以显然不会树化，继续执行，将当前元素添加到指定索引的链表末尾。继续往下执行，还可以发现一个if

我们指定map里面key是唯一的，如果添加2个相同的key，那么前面个key的值就会被覆盖，这里的if就是用来完成这个事情的。继续debug

执行到这里，debug也就基本结束了，最后来看看table的结构

---

put方法（有冲突，树化）

上面看见了当链表个数达到9个的时候会进行树化，链表变换为红黑树，下面就来debug这个过程

    public static void main(String[] args) {
        HashMap<FixHashCat, String> hashMap = new HashMap<>();
        for (int i = 0; i < 8; i++) {
            hashMap.put(new FixHashCat(), i + "");
        }
        hashMap.put(new FixHashCat(), "8");
    }

我使用上面代码进行debug，查看hashMap.put(new FixHashCat(), “8”)这条语句添加时候的情况

前面相同的部分我就跳过了，直接从树化部分开始

进入到treeifyBin，结果由于table容量太小(这里是16)，于是会重设table大小，并不会树化。

为了看到树化的过程，我在创建HashMap的时候指定初始容量

    public static void main(String[] args) {
        HashMap<FixHashCat, String> hashMap = new HashMap<>(128);
        for (int i = 0; i < 8; i++) {
            hashMap.put(new FixHashCat(), i + "");
        }
        hashMap.put(new FixHashCat(), "9");
    }

还是debug到treeifyBin

简单看一下replacementTreeNode，代码很简单，如下

对于do-while里面的内容我并不关心，直接跳到if语句

可以看一下hd的内容

下面就是执行treeify方法

对于这个方法，完全就是属于数据结构了，这里不进行说明，大家可以自行查看源代码。现在我直接看看执行完该方法后产生的树

可以发现树节点就是通过TreeNode来存储的，用于快速查找。

现在关于树化的debug就结束了，现在我想对上面提到的TreeNode进行一下说明

就是p instanceof TreeNode，这个在上面提到过，现在大家应该可以看懂了，树化之后的节点就是TreeNode，如果是TreeNode，那么就要将其添加到树，而不是链表尾部。

remove方法（树退化）

对于HashMap，不仅仅会将链表变化为树，当树的元素个数小于某个阈值时，树也会退化为链表

上面分别是树化和退化的阈值。

当我们删除元素的时候可能就会进行退化，树变成链表

---

常见方法

在这里介绍一些HashMap里面经常使用到的方法

方法名称	作用
entrySet()	返回所有元素的set集合(k-v形式)
getOrDefault(Object key, V defaultValue)	返回指定key对于的value，如果不存在就返回defaultValue
keySet()	返回所有的key
values()	返回所有的value
forEach	遍历集合元素
containsKey(Object key)	是否包含指定key
containsValue(Object value)	是否包含指定value

---

总结

HashMap使用K-V的形式存储数据，Map的扩容机制是按照2倍进行的，当达到阈值时就会扩容。当hash冲突严重时，链表会转换为红黑树，当树元素个数很少时，又会退化为链表。