Java8 Map数据结构及常用方法源码详解

目录

 

map数据结构

 构造方法以及重要字段说明

具体方法解读

put方法：

get方法：

remove方法：

clear方法：

containsValue方法：

putAll方法：

size方法：

isEmpty方法：

keySet方法

---

map数据结构

这儿对数据结构的说明，只是单纯的讲解存储结构，没有考虑key的判重以及扩容，具体细节可以阅读下面对源码的解读

Map的存储结构是数组+链表+树(红黑树)。数组的每个位置放的是一个链表（单向列表），也有可能放的是一颗红黑树（当数组的某一个位置的链表的长度达到某一个特定的值的时候，会将该位置的链表转为红黑树）。下面通过一个例子来详细说明map中元素的存储结构：

假如要将key值为999999999、999999998、132、133、12的五个键值对放到map里面（此处我们不关心值是什么，只关心键，而且假设这几个key的value不重复，具体的可以看下面的源码解释），存储过程如下：

假如数组如下（初始容量为16）：

在将元素放进去之前首先要确定key在数组中的位置下标，这需要通过key的hash值、特定的算法以及数组的容量来确定，公式如下（假设数组的容量为n）：

key的hash值：h = key.hashCode();

下标 = (n - 1) & (h ^ (h >>> 16))      // >>> 表示无符号右移，这儿意思是将h的低16位移除，高位（包含符号位）用0补充

第一次：把key=999999999的元素放进去，过程如下：

999999999的hash值仍然为999999999，即h = 999999999

下标 = (16 - 1) & (999999999 ^ (999999999 >>> 16)) = 5

放置结果（不关心value,只关心key）:

第二次：把key=999999998放进去：

999999998的hash值也是999999998，即h=999999998

下标 = (16 - 1) & (999999998^ (999999998>>> 16)) = 4

放置结果（不关心value,只关心key）:

第三次：key = 132：

132的hash值是132，即h = 132

下标 = (16 - 1) & (132^ (132>>> 16)) = 4

结果:

 第四次：key=133：

h = 133

下标 = (16 - 1) & (133^ (133>>> 16)) = 4

第五次：key=12

h = 12

下标=(16 - 1) & (12^ (12>>> 16)) = 12

结果：

 构造方法以及重要字段说明

源码解读：

HashMap中的比较重要的字段说明：

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;  //初始容量 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 MIN_TREEIFY_CAPACITY = 64;  //单链表变成红黑树之前数组的最小长度，使用方法如下：

final void treeifyBin(Node[] tab, int hash) {
    int n, index; Node e;
    //如果数组的长度小于MIN_TREEIFY_CAPACITY，则仍然执行扩容，不会转化树
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode hd = null, tl = null;
        do {
            TreeNode 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);
    }
}

transient Node[] table;  //map的底层数组结构，是一个Node类型的数组，Node是HashMap的一个内部类
transient int size;  //map中已经存在的元素个数
int threshold;  //map扩容的阀值，元素个数达到该值就扩容
final float loadFactor;   //扩容因子

在下面的源码解释中就可以看到这些字段的运用了。

首先看看构造方法，有四个构造方法：

1.可以指定初始容量和加载因子，而且会判断初始容量是否大于最大值，如果大于最大值就取最大值，加载因子不能小于0，

此处传入初始容量主要影响的是扩容阀值，扩容阀值是根据传入的容量计算出来的

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;
        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;
    }

2.只指定初始值，其实还是调了第一个构造方法，加载因子用的是默认值0.75

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

3.什么也不指定构造方法光初始化加载因子为默认值 0.75

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

4.入参是一个Map类型的集合，根据下面putMapEntries方法的源代码可以知道其实内部是循环调了HashMap的put方法的

public HashMap(Map m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

final void putMapEntries(Map m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            //初始化的时候需要先初始化才可以放进去
            if (table == null) { // pre-size
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            else if (s > threshold)
                resize();
            //循环调用putVal方法，将元素放到map里面
            for (Map.Entry e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

具体方法解读

常用方法：

put(key, value);

get(key);

remove(key);

clear();

containsValue(value);

putAll(Map m);

size();

isEmpty();

put方法：

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

//计算hash值，key自己的hash值和自己hash值右移16位得到的值按位异或，据说这样计算得出的下标分布比较均匀
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

/**
     * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value,put方法传入的该值是false
     * @param evict if false, the table is in creation mode,put方法传入的该值是true
     * @return previous value, or null if none,返回值是null，什么时候返回的不是null呢,就是当传入的key值在map中已经存在，那么此时传入的新值会将旧值覆盖，这儿的返回值就是旧值。
     */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        Node[] tab; Node p; int n, i;
        //首先判断table（map底层数组）是不是空的，如果是的话就需要先扩容（其实也就是初始化）
        if ((tab = table) == null || (n = tab.length) == 0)
            //n就是数组的长度（注意：是长度，不是数组中元素个数）
            n = (tab = resize()).length;
        /*这儿的i就是数组下标，计算方式：(n - 1) & hash，这也就是开篇的时候下标的计算方式。
          判断下标所在位置是否已经有值，如果没有那么就创建一个Node对象放到该位置。
          Node是HashMap的一个内部类，map的键值对就是在该类型的对象里面存放，而且里面还有指向下一个元素的指针，可以认为Node对象是Map数据结构中最基本的存储单位。
          Node类源码看下面。
        */
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {  /*如果前面计算出来的下标所在位置已经有值，则进入该else，
          比如开篇的时候将132和133放进去的时候，计算出来的下标所在位置就已经有值了
                */
            Node e; K k;
            /*判断当前下标所在位置的Node对象的哈希值以及key是否相等，
          判断key值是否相等的时候需要通过==和equals方法（Node对象重写equals方法的原因）
            */
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //如果判断结果是相等，则将当前值赋给变量e
                e = p;
            else if (p instanceof TreeNode)
                //判断当前节点类型是不是树，如果是的话就在树里面操作新增
                e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
            else {
                /*当计算出来的下标所在的位置已经有值并且和传入的key以及哈希值不相等就会执行到这儿，
然后通过循环判断，当循环到某个节点的时候，判断该节点的下一个节点是否为null，如果为null则通过传入值新建一个节点，链接到该节点的下一个节点
                */
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //当列表的长度达到8的时候TREEIFY_THRESHOLD=8，通过treeifyBin方法将列表转化为红黑树(只是执行转化树的逻辑，在具体方法里面还有判断)
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //如果循环到的节点的next节点不空，判断next节点的hash值以及key值和传入的是否相等，如果相等，则跳出，后面用新值覆盖旧值
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //判断e是否为空，当面判断哈希值以及key值得到的结果是相等的时候，进入该if里面
            if (e != null) { // existing mapping for key
                //记录旧值
                V oldValue = e.value;
                //put方法传入的onlyIfAbsent 是false，所以该if条件一定能进去，并且用新值将旧替换
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                //HashMap中该方法为空方法
                afterNodeAccess(e);
                //返回旧值
                return oldValue;
            }
        }
        //记录map的修改次数
        ++modCount;
        //map的元素数量加1，并且和扩容阀值比较，如果元素数量大于扩容阀值，则对map进行扩容
        if (++size > threshold)
            resize();
        //HashMap中该方法为空方法
        afterNodeInsertion(evict);
        return null;
}

//创建一个Node对象
Node newNode(int hash, K key, V value, Node next) {
    return new Node<>(hash, key, value, next);
}

//重写了hashCode和equels方法，这两个方法要重写的话必须都重写，两者应该是保持一致的，在看代码的过程中应该能感受到为什么需要都重写
static class Node implements Map.Entry {
        final int hash; //哈希值
        final K key;  //key
        V value;  //value
        Node next;  //指向下一个元素的指针，连接起来就是一个单向链表

        Node(int hash, K key, V value, Node 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;
        }
}

扩容方法：

/*什么时候会调扩容方法
一是添加第一个元素的时候会调,来初始化table
二是当数组中元素超过扩容阀值（threshold）
*/
final Node[] resize() {
        //旧的底层数组
        Node[] oldTab = table;
        //旧的数组长度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //旧的扩容阀值
        int oldThr = threshold;
        //新的容量、新的扩容阀值
        int newCap, newThr = 0;
        if (oldCap > 0) {
            //如果旧容量大于0，则判断是否已经达到最大值，如果是的话则扩容阀值设置为整数最大值（也就是说往后不会再扩容了），理论上应该是不会达到该值的，估计还没达到该值，已经内存溢出了（这可是10亿级别的数据量）
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            /*
            正常情况下会执行到这一步
            新的容量扩为旧容量的两倍 （newCap = oldCap << 1）
            同时判断扩容后的容量是否超过最大值，如果超过则不进入该else if，跳到newThr==0的那一步
            如果没有超过，再判断旧容量是否大于等于默认容量16（一般来说该条件肯定是满足的，因为初始化的时候容量最小就是16）
            至于是否大于最大值，我觉得这个条件可以不考虑，在超过最大值之前内容首先会蹦...
            */
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                //扩容阀值也扩大为原来的两倍
                newThr = oldThr << 1; // double threshold
        }
        /*
        将扩容阀值赋给新容量（旧容量为0并且扩容阀值大于0的时候会执行这一步）
        */
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            //添加第一个元素的时候就会执行这儿，将容量初始化为16
            newCap = DEFAULT_INITIAL_CAPACITY;
            //扩容阀值初始化为初始容量的0.75倍
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        /*
        什么时候会执行该if
        当执行了else if (oldThr > 0)分支  或者是 旧容量扩为两倍后大于最大值（这种情况基本不用考虑，因为基本上不可能出现）
        这儿是设置新的扩容阀值的值，设置为新容量的0.75倍
        */
        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[] newTab = (Node[])new Node[newCap];
        table = newTab;
        
        if (oldTab != null) {
            //下面就是通过循环进行数组的复制过程了
            for (int j = 0; j < oldCap; ++j) {
                Node e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;  //将旧数组的内容设置为null
                    if (e.next == null)  //旧的链表只有一个节点
                        //重新计算下标，计算规则还是一样的
                        newTab[e.hash & (newCap - 1)] = e;  
                    //如果旧的某一个位置（有的地方也叫桶）放的是树，则走树的逻辑
                    else if (e instanceof TreeNode)  
                        ((TreeNode)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        //如果某一个桶里面放的不只是一个节点，而是一个链表
                        Node loHead = null, loTail = null;
                        Node hiHead = null, hiTail = null;
                        Node next;
                        do {
                            next = e.next;
                            /*
                    这儿会根据当前节点的哈希值和旧数组的容量值做按位与运算（&）
                    通过判断运算按位与运算结果是否为0位判断条件，将原来的一个链表拆为两个列表
                    然后运算结果为0得到的链表放到新数组下标为当前j值的位置
                    不为0得到的链表放到新数组下标为当前j值+旧数组容量值的位置
                    到此扩容就完成了
                            */
                            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;
    }

扩容中有涉及到堆红黑树的操作（还在研究中）。

get方法：

只要把上面的put方法搞明白了，后面的这些方法都非常容易理解了

public V get(Object key) {
        Node e;
        //首先计算hash值,计算下标用
        return (e = getNode(hash(key), key)) == null ? null : e.value;
}

/*大体就是先计算下标，然后在相应的链表里面通过循环查询
每遍历出来一个节点然后比较该节点哈希值以及key值和传入的哈希值以及key值是否相等
*/
final Node getNode(int hash, Object key) {
        Node[] tab; Node first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //判断链表的第一个节点
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    //如果头节点是树类型，则说明这儿事一颗树，到树的里面去查找，否则到下面的循环中查询
                    return ((TreeNode)first).getTreeNode(hash, key);
                //do循环
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
}

remove方法：

//同样是先计算hash值，用于计算数组下标
//返回值是删除的Node的value值
public V remove(Object key) {
        Node e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
}

/**
     * Implements Map.remove and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value      这儿传入的value是null
     * @param matchValue 这儿传入的该参数是false
     * @param movable    这儿转入的改参数是true
     * @return the node, or null if none
     */
final Node removeNode(int hash, Object key, Object value, boolean matchValue,    boolean movable) {
        Node[] tab; Node p; int n, index;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            //根据计算得到的数组下标获取链表（树）
            (p = tab[index = (n - 1) & hash]) != null) {
            Node node = null, e; K k; V v;
            //判断链表（树）的第一个节点是否是要删除的节点
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)
                    //如果是树，就到树里面去查找要删除节点
                    node = ((TreeNode)p).getTreeNode(hash, key);
                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不为空，则执行删除
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                if (node instanceof TreeNode)  //到树里面删除
                    ((TreeNode)node).removeTreeNode(this, tab, movable);
                else if (node == p)  //如果node就是链表的头结点，直接操作数组
                    tab[index] = node.next;
                else
                    //循环的过程中，node（循环中的e）是循环当前的节点，p是node的前一个节点，删除就很简单了
                    p.next = node.next;
                //记录该map的修改数量
                ++modCount;
                //容量减1
                --size;
                //空方法
                afterNodeRemoval(node);
                //返回删去的node
                return node;
            }
        }
        return null;
}

clear方法：

//将数组中每一个桶都置为null
public void clear() {
        Node[] tab;
        modCount++;
        if ((tab = table) != null && size > 0) {
            size = 0;
            for (int i = 0; i < tab.length; ++i)
                tab[i] = null;
        }
}

containsValue方法：

//循环遍历数组中的每个节点，并通过==和equals方法比较
//如果map中的value值是对象的话，使用此方法要注意equals方法的重写
//这儿有一点不明白，为什么没有判断数组中的第一个节点的类型是不是树然后去树里面查找（希望明白的同学可以帮忙解释一下）
public boolean containsValue(Object value) {
        Node[] tab; V v;
        if ((tab = table) != null && size > 0) {
            for (int i = 0; i < tab.length; ++i) {
                for (Node e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                        (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
}

putAll方法：

//该方法最终还是调了putVal方法，逻辑和put方法一样
public void putAll(Map m) {
        putMapEntries(m, true);
}

final void putMapEntries(Map m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            if (table == null) { // pre-size
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            else if (s > threshold)
                resize();
            for (Map.Entry e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                //最终调了putVal方法
                putVal(hash(key), key, value, false, evict);
            }
        }
}

size方法：

public int size() {
        return size;
    }

isEmpty方法：

public boolean isEmpty() {
        return size == 0;
    }

keySet方法

这个方法感觉太神奇了，就直接new了一个内部类KeySet的对象，然后就取到map所有的key值了，查看了继承的所有父类也没有搞明白，找不到头绪。。。

对values()方法和entrySet()方法也存在同样的疑问，三个应该是一样的原理

一直没有想明白（如鲠在喉啊...），希望有明白其中原理的同学能够帮忙讲解一下，在此谢过了！！！

public Set keySet() {
        Set ks = keySet;
        if (ks == null) {
            ks = new KeySet();
            keySet = ks;
        }
        return ks;
    }

    final class KeySet extends AbstractSet {
        public final int size()                 { return size; }
        public final void clear()               { HashMap.this.clear(); }
        public final Iterator iterator()     { return new KeyIterator(); }
        public final boolean contains(Object o) { return containsKey(o); }
        public final boolean remove(Object key) {
            return removeNode(hash(key), key, null, false, true) != null;
        }
        public final Spliterator spliterator() {
            return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
        }
        public final void forEach(Consumer action) {
            Node[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node e = tab[i]; e != null; e = e.next)
                        action.accept(e.key);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
    }

有错误的地方还希望指正。