基于JDK1.8的HashMap源码分析

HashMap底层数据结构

如图:

HashMap的底层数据结构及初始化参数源码:

/*HashMap中数组table的默认初始化容量,必须是2的幂次方*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/*HashMap中数组table的最大容量,值为(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;
/*树形化的HashMap的容量阈值,如果链表长度已经达到转化红黑树阈值,但是HashMap容量未达到这个阈值,则只进行扩容resize,不进行树形化*/
static final int MIN_TREEIFY_CAPACITY = 64;
/*数组table中存放的元素为Node对象*/
static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
        ...
}
/*数组table中存放的元素是Node对象*/
transient Node<K,V>[] table;
// 临界值 当实际节点个数超过临界值(容量*填充因子)时,会进行扩容
int threshold;
// 哈希表的负载因子,默认使用的是DEFAULT_LOAD_FACTOR
final float loadFactor

说明:

1.从JDK1.8开始,hashmap的底层数据结构为数组table+(单)链表+红黑树的存储方式,当链表长度超过阈值（8）且当前数组table的长度(即HashMap容量)达到阈值(64)时,将链表转换为红黑树,这样大大减少了查找时间;

2.从上面可以看到,首先有数组table,每个数组元素上都有一个链表结构,当添加一个元素（key-value）时,首先计算元素key的hash值,以此确定插入数组中的位置,但是可能存在同一hash值的元素已经被放在数组同一位置了,这时就将后面的添加进来的元素放到同一hash值(/位置)的链表节点元素的后面,他们在数组的同一位置,但是形成了链表,同一各链表上的Hash值是相同的,所以说数组中存放的是链表(结构).而当链表长度太长时(达到阈值8)且数组table长度(即HashMap容量)达到阈值(64)时,链表就转换为红黑树,这样大大提高了查找的效率;

3.当数组table的容量超过初始容量的0.75时,再散列将数组table进行扩容,把原链表元素搬移到新的数组中;

4.负载因子（默认0.75）;为什么需要使用加载因子?为什么需要扩容呢?

因为如果元素填充比很大,说明利用的空间很多,如果一直不进行扩容的话,链表就会越来越长,这样查找的效率很低,因为链表的长度很大（当然最新版本使用了红黑树后会改进很多）,扩容之后,将原来数组table的每一个链表分成奇偶两个子链表分别挂在新的数组table的散列位置,这样就减少了每个链表的长度,增加查找效率

HashMap的get()方法分析

/*通过get(key)方法查找数据时候,在get(key)方法中先获取key的hash值,然后调用getNode(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;
        //首先通过"hash&(n-1)"算法得到索引,然后通过索定位到数组table中对应位置的元素(first=tab[hash&(n-1)])
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //先判断这个first元素中的hash值和传入的参数key的hash值是否相等以及这个first元素中的key的值和传入的key的值是否相等:
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                //如果都相等,则表示这个元素就是我们要查找的元素,返回这个元素;
                return first;
            
            //如果不相等,就要按照链表形式判断当前节点的下一个节点是否为null:
            if ((e = first.next) != null) {
                //如果当前节点元素的下一个节点不为null,那么就要判断当前节点元素的节点类型:
                if (first instanceof TreeNode)
                    //如果当前这个节点元素是一个treenode的节点,那么就按照红黑树方式查找对应的元素节点,然后返回元素的value值即可
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                //否则按照链表形式查找对应的元素节点然后返回元素的value值即可
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        //hashMap中没有任何数据或者要查找的元素不存在,返回null;
        return null;
}

HashMap的put()方法分析

public V put(K key, V value) {
        //计算Key的hash值,然后将相关参数传入调用的putVal()方法
        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是否为空或为null,如果为null就扩容;否则直接下一步
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //根据key的hash值进行计算得到插入的数组table中对应元素的索引I,如果这个位置为null,则表示该位置还没有被占用,那么直接将参数组装成一个链表节点元素添加到该位置
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            //如果该位置已经被占用了,那么就要判断当前已经占用这个位置的节点元素的(key的)hash值跟将要插入的key的hash值以及两个key的本身值是否相等:
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //如果都相等,则表示这两个元素的key是一样的,hashmap中已经存在了key相同的元素,那么久将已经存在的元素取出来,临时存储到一个Node中,到后面进行value属性替换/更新
                e = p;
            else if (p instanceof TreeNode)
                //如果不全相等,那么就要判断当前这个位置节点元素的类型
                //如果是TreeNode,则将传入的参数按照红黑树方式添加到红黑树中
                //注意:如果是新加入节点(即hash值和key的值不全相等或者添加的元素在树中不存在),返回的对象(e)就是null;如果新加入的元素在红黑树中已经存在了,则返回的对象(e)就是已经存在的那个节点
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //如果不全相等,那么就要判断当前这个位置节点元素的类型
                //如果当前节点不是Treenode类型,那么他就是一个链表结构
                for (int binCount = 0; ; ++binCount) {
                    //那么就遍历当前链表结构,然后判断当前节点元素的下一个节点是否为null
                    if ((e = p.next) == null) {
                        //如果当前节点元素的下一个节点是null,则将传入的参数组装成一个链表的节点元素,再将当前节点的下一个节点的引用指向新组装的节点
                        p.next = newNode(hash, key, value, null);
                        
                        //再判断当前数组table中这个位置的链表的长度是否达到了阈值(8)且当前数组table的长度(即HashMap容量)是否到达了树形化的阈值(默认是64),如果都成立则进行树化(将链表转换成红黑树);如果链表长度达到了阈值(8),但是数组长度(即HashMap容量)并未达到树形化阈值(64),那么就不需要进行树化,只对数组table进行扩容,在扩容的时候,如果数组table不是null,那么还需要将数组table中的每个元素(链表/红黑树)放到新的数组newtab[]中)
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    
                   //如果当前节点元素的下一个节点不是null,则判断(当前节点的)下一个节点元素中的hash值及key本身的值与传入的元素的key的hash和key本身的值是否都相等:
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        //如果都相等跳出循环,执行后面的value属性替换;
                        break;
                    //如果不相等,那么当前节点的下一个节点就变成了当前节点,继续循环往后找
                    p = e;
                }
            }
            
            //hashmap中已经存在名称相同的key对应元素或者说key的映已经存在了
            if (e != null) { // existing mapping for key
                //取出已经存在的key名称相同的元素的value值,存放到一个临时变量中
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    //将已经存在的名称相同的key对应的元素的value属性重新赋值
                    //或者将后面添加的名称相同的key对应元素的value值替换/覆盖之前已经存在的key名称相同的元素的value值
                    e.value = value;
                afterNodeAccess(e);
                //返回已经的key相同的元素的旧值(更新/替换之前的值)
                return oldValue;
            }
        }
    
        //modCount用于记录HashMap的修改次数,如果modCount改变的不符合预期,那么就会抛出异常
        //由于HashMap不是线程安全的,所以在迭代的时候,会将modCount赋值到迭代器的expectedModCount属性中,然后进行迭代,如果在迭代的过程中HashMap被其他线程修改了,modCount的数值就会发生变化,这个时候expectedModCount和ModCount不相等,迭代器就会抛出ConcurrentModificationException()异常
        ++modCount;
    
        //判断是否需要扩容
        if (++size > threshold)
            //当前HashMap中的总的kv键值对元素的个数是否达到扩容阈值,如果大于,就需要对数组table进行扩容
            //(扩容阈值=数组table的容量*加载因子;第一次为16*0.75=12,之后就是:((数组的长度*2)*0.75)
            resize();
        afterNodeInsertion(evict);
        return null;
 }

HashMap的扩容机制

扩容的时机?

①.第一次add添加数据的时候,键值对数组为null,需要扩容;初始容量为16,扩容阈值为:16*0.75=12;

②.每次添加一个新元素(元素的key与当前HashMap中已经存在元素的key不匹配)之后需要判断当前HashMap元素(k-v对)总个数是否大于扩容阈值,如果是,那么就需要扩容;扩容之后容量为:上一次的扩容之后的容量x2,扩容阈值为:上一次的扩容阈值x2;否则,不需要扩容;

③.在添加链表节点时,如果链表的长度达到阈值(8)且键值对数组长度达到阈值(64),也要进行扩容;扩容之后容量=上一次的扩容之后的容量x2,扩容阈值=上一次的扩容阈值x2;

扩容之后会产生一个新的数组newTable[],如果原来的数组table不是null,那么还需要将原来数组table中的元素全部(节点/链表/红黑树)添加到新的键值对数组中

源码:

final Node<K,V>[] resize() {
        //当前table保存
        Node<K,V>[] oldTab = table;
        //保存table大小
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //保存当前阈值
        int oldThr = threshold;
        int newCap, newThr = 0;
        // 如果老的容量大于0
        if (oldCap > 0) {
            // 如果容量大于容器最大值
            if (oldCap >= MAXIMUM_CAPACITY) {
                //阈值设为int最大值
                threshold = Integer.MAX_VALUE;
                //返回老的数组,不再扩充
                return oldTab;
            }// 如果老的容量*2 小于最大容量并且老的容量大于等于默认容量
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                // 新的阈值也在老的阈值基础上*2
                newThr = oldThr << 1; // double threshold
        }// 如果老的阈值大于0
        else if (oldThr > 0) // initial capacity was placed in threshold
            // 新容量等于老阈值
            newCap = oldThr;
        else {  // 如果容量是0,阈值也是0,认为这是一个新的数组,使用默认的容量16和默认的阈值12           
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 如果新的阈值是0,重新计算阈值
        if (newThr == 0) {
            // 使用新的容量 * 负载因子（0.75）
            float ft = (float)newCap * loadFactor;
            // 如果新的容量小于最大容量 且 阈值小于最大 则新阈值等于刚刚计算的阈值,否则新阈值为 int 最大值
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        } 
        // 将新阈值赋值给当前对象的阈值.
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            // 创建一个Node 数组,容量是新数组的容量（新容量要么是老的容量,要么是老容量*2,要么是16）
            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;
                // 如果老数组对应下标的值不为空
                if ((e = oldTab[j]) != null) {
                    // 设置为空
                    oldTab[j] = null;
                    // 如果老数组没有链表
                    if (e.next == null)
                        // 将该值散列到新数组中
                        newTab[e.hash & (newCap - 1)] = e;
                    // 如果该节点是树
                    else if (e instanceof TreeNode)
                        // 调用红黑树 的split 方法,传入当前对象,新数组,当前下标,老数组的容量,目的是将树的数据重新散列到数组中
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // 如果既不是树,next 节点也不为空,则是链表,注意,这里将优化链表重新散列（java 8 的改进）
                      // Java8 之前,这里曾是并发操作会出现环状链表的情况,但是Java8 优化了算法.此bug不再出现,但并发时仍然不建议HashMap
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        //将原来的链表切成两段,两段链表的第一个节点的下标相差16
                        do {
                            next = e.next;
                            // 这里的判断需要引出一些东西：oldCap 假如是16,那么二进制为 10000,扩容变成 100000,也就是32.
                            // 当旧的hash值 与运算 10000,结果是0的话,那么hash值的右起第五位肯定也是0,那么该于元素的下标位置也就不变
                            //这里的重新hash 不是使用的 [e.hash & (newCap - 1)] 方法,而是使用更加效率的方法,直接 hash 老的数组容量,就没有了减一的操作
                            if ((e.hash & oldCap) == 0) {
                                // 第一次进来时给链头赋值
                                if (loTail == null)
                                    loHead = e;
                                else
                                    // 给链尾赋值
                                    loTail.next = e;
                                // 重置该变量
                                loTail = e;
                            }
                            // 如果不是0,那么就是1,也就是说,如果原始容量是16,那么该元素新的下标就是：原下标 + 16（10000b）
                            else {
                                // 同上
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        // 理想情况下,可将原有的链表拆成2组,提高查询性能.
                        if (loTail != null) {
                            // 销毁实例,等待GC回收
                            loTail.next = null;
                            // 置入bucket中
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

总结:

①.扩容的时候会重新进行内存分配,并且会遍历HashMap中所有的元素,是非常耗时的.在编写程序中.要尽量避免resize.

②.如果kv映射很多,创建HashMap时设置充足的初始容量(预计大小/负载因子 + 1）会比让其自动扩容获得更好的效率,一方面减少了碰撞可能,另一方面减少了resize的损耗

HashMap删除元素的方法

public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

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;
    if ((tab = table) != null && (n = tab.length) > 0 &&   // table数组非空，键的hash值所指向的数组中的元素非空
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;     // node指向最终的结果结点，e为链表中的遍历指针

        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<K,V>)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);
            }
        }
        if (node != null && (!matchValue || (v = node.value) == value ||         //判断是否存在，如果matchValue为true，需要比较值是否相等
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode)   //树
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)   //匹配第一个节点
                tab[index] = node.next;
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

// 清空整个hashmap
public void clear() {
    Node<K,V>[] tab;
    modCount++;
    if ((tab = table) != null && size > 0) {
        size = 0;
        for (int i = 0; i < tab.length; ++i)
            tab[i] = null;
    }
}

HashMap的初始化容量

①.默认情况下HashMap的容量是16,但是,如果用户通过构造函数指定了一个数字作为容量,那么HashMap会选择大于该数字的第一个2的幂作为容量.例如: 3->4、7->8、9->16

②.如果我们没有设置初始容量大小,随着元素的不断增加,HashMap会发生多次扩容,而HashMap中的扩容机制决定了每次扩容都需要重建hash表,是非常影响性能的.

③.为了有效提高性能.我们需要在创建HashMap时设置一个合理初始化容量,根据<<阿里巴巴Java开发者手册>>中建议:

initialCapacity = (需要存储的元素个数 / 负载因子) + 1;

注意:负载因子（即loaderfactor）默认为 0.75,如果暂时无法确定初始值大小,请设置为 16（即默认值）

HashMap的Fail-Fast机制

1>.我们知道 java.util.HashMap 不是线程安全的,因此如果在使用迭代器的过程中有其他线程修改了map,那么将抛出"ConcurrentModificationException"异常,这就是所谓fail-fast策略

2>这一策略在源码中的实现是通过 modCount 域,modCount 顾名思义就是修改次数,对HashMap 内容的修改都将增加这个值,那么在迭代器初始化过程中会将这个值赋给迭代器的 expectedModCount

/**
     * HashIterator是HashMap的一个内部抽象类,为HashMap的迭代器
     */
    abstract class HashIterator {
        // 下一个结点
        Node<K,V> next;        // next entry to return
        // 当前结点
        Node<K,V> current;     // current entry
        // 期望的修改次数fast-fail机制
        int expectedModCount;  // for fast-fail
        // 当前桶索引
        int index;             // current slot
        /**
         * next将表示第一个非空桶中的第一个结点,index将表示下一个桶
         */
        HashIterator() {
            expectedModCount = modCount;
            Node<K,V>[] t = table;
            current = next = null;
            index = 0;
            // table不为空并且大小大于0
            if (t != null && size > 0) { // advance to first entry
                 // 找到table数组中第一个存在的结点,即找到第一个具有元素的桶
                do {} while (index < t.length && (next = t[index++]) == null);
            }
        }
        // 是否存在下一个结点
        public final boolean hasNext() {
            return next != null;
        }
        /**
          * nextNode函数屏蔽掉了桶的不同所带来的差异,就好像所有元素在同一个桶中,依次进行遍历
          */
        final Node<K,V> nextNode() {
            Node<K,V>[] t;
            // 记录next结点
            Node<K,V> e = next;
            // 若在遍历时对HashMap进行结构性的修改则会抛出异常
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            // 下一个结点为空,抛出异常
            if (e == null)
                throw new NoSuchElementException();
            // 如果下一个结点为空,并且table表不为空;表示桶中所有结点已经遍历完,需寻找下一个不为空的桶
            if ((next = (current = e).next) == null && (t = table) != null) {
                // 找到下一个不为空的桶
                do {} while (index < t.length && (next = t[index++]) == null);
            }
            return e;
        }

        public final void remove() {
            Node<K,V> p = current;
            // 当前结点为空，抛出异常
            if (p == null)
                throw new IllegalStateException();
            // 若在遍历时对HashMap进行结构性的修改则会抛出异常
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            // 当前结点为空
            current = null;
            K key = p.key;
            // 移除结点
            removeNode(hash(key), key, null, false, false);  
            // 赋最新值
            expectedModCount = modCount;
        }
    }

说明:

①.HashIterator是一个抽象类,封装了迭代器内部工作的一些操作;
②.在迭代过程中,判断modCount跟expectedModCount是否相等,如果不相等就表示已经有其他线程修改了Map,直接抛出"ConcurrentModificationException"并发修改异常

3>.在HashMap的API中指出:

由所有HashMap类的"collection视图方法"所返回的迭代器都是快速失败的;在迭代器创建之后,如果从结构上对映射进行修改,除非通过迭代器本身的remove方法,其他任何时间任何方式的修改,迭代器都将抛出"ConcurrentModificationException".因此,面对并发的修改,迭代器很快就会完全失败,而不冒在将来不确定的时间发生任意不确定行为的风险

注意:迭代器的快速失败行为不能得到保证,一般来说,存在非同步的并发修改时,不可能作出任何坚决的保证.快速失败迭代器尽最大努力抛出"ConcurrentModificationException"异常.因此,编写依赖于此异常的程序的做法是错误的,正确做法是:迭代器的快速失败行为应该仅用于检测程序错误