HashMap源码分析(搞懂HashMap看这个就够了)

首先来看看HashMap，从构造函数看起

HashMap有四个构造函数

第一个：

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

无参的构造函数，初始容量为默认的16不变，loadFactor为负载因子，也是默认的0.75

 

第二个：

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

调用第三种构造函数，建立一个大小为initialCapacity，负载因子为0.75的hashmap

第三个：

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

参数为大小和负载因子，建立参数为initialCapacity，负载因子为loadFactor的hashmap

当大小大于MAXIMUM_CAPACITY(1<<30)时，就把大小设为最大

否则调用threshold设定大小(因为大小必须为2的次方数)

tableSizeFor的代码为:

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

比如：预设定的大小cap = 6

n=6-1=5

n：      0000 0101

n>>1：0000 0010

n|=.. ：0000 0111

 

n：      0000 0111

n>>2：0000 0001

n|=：   0000 0111

......

n最终结果是0000 0111

这个运算的结果就是算出cap的最高非零位开始后面低位都是1的结果

因为5的最高非零位在倒数第三位，所以倒数第三位及以后都是1

之后对n+1，得出0000 1000

也就是8

所以这个方法就是得出大于等于cap的最小的2的幂次方

因为5<8,所以得出最终结果就是8

 

那为什么一开始cap要减一呢,就是为了边界问题，针对cap=2的幂次的情况

比如cap=8时，如果不减一的话：

n = cap

n：      0000 1000

n>>1：0000 0100

n|=：   0000 1100

 

n：      0000 1100

n>>2：0000 0011

n|=：   0000 1111

......

n最终结果为0000 1111

之后对n+1，得出0001 0000，结果为16

但是我们一开始要的大小只是8啊，这给的多了一倍，浪费啊，浪费啊！

所以一开始减一，那么cap是8的时候，n就是7，那最终运算出的n就是8了

 

第四个：

 public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

构造一个大小和指定map一样大的新map，负载因子为0.75

我们来看看第四个构造函数怎么实现的，通过调用putMapEntries方法

​
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        //通过s保存指定map的大小
        int s = m.size();
        //当指定的map m中有值时
        if (s > 0) {
            //如果table没初始化，进行一些初始化
            if (table == null) { // pre-size
                //根据要存入map的值确定新map的容量
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                //把要创建的容量大小值存入threshold
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            //table初始化时，别的方法可能也会调用这个方法
            //所以如果table已经初始化，判断初始化的大小和指定map的大小
            //如果比指定map的大小小，存不下，就需要resize()重新设定大小
            else if (s > threshold)
                resize();
            //遍历m，将里面的值都放到新map之中
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

​

先来看看上面代码调用的resize()方法

​
final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        //表的大小指的是表里面元素的数量，表的容量指的是最大可容纳的元素数量
        //获取老表的大小
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        //如果老表不为空
        if (oldCap > 0) {
            //threshold是hashmap所能容纳的最大数据量的Node个数
            //如果老表大小大于最大值
            if (oldCap >= MAXIMUM_CAPACITY) {
                //把个数大小设置为最大值
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //如果老表容量扩大两倍可以存下，那就把容量扩大为原来的两倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        //如果老表为空，同时老表大小大于0，那么新表长度就为老表容量
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        //如果老表大小为0，新表长度设为默认的16
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            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;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        //把老表中的数据rehash到新表当中
        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)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    //若节点是链表节点，进行链表的哈希操作
                    else { // preserve order
                        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;
    }

​

HashMap通过链表法避免冲突

当链表长度大于8时，把链表转换为红黑树

当链表长度小于6时，又转回链表

而存储hashmap值的数据结构为数组

所以hashmap的数据结构组成为数组，链表，红黑树。

我们再来看看之前的putVal方法

putVal(hash(key), key, value, false, evict);

看putVal之前先看看hash方法

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

将key的hashcode值与他的hashcode右移16位的结果进行异或运行，得出哈希值

这样做的原因：高低位混合进行异或运算，增大随机性

putVal()方法如下所示：

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位空则resize
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //如果要存入的槽还没有元素存入，那把这个元素直接存入
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        //要存入的值中已经有值
        else {
            Node<K,V> e; K k;
            //key与原来存在这个位置的key相同，只更新value
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //如果这个位置是红黑树，那么按红黑树的方法存
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //如果是链表，那么按链表的方法存
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

JDK1.7及以前没有红黑树这个数据结构，只是通过链表来处理冲突

所以采用头插法效率高

但是这样可能会产生两个问题

一是链表逆序

二是可能死循环

红黑树采用尾插法解决了这个问题

 

安全性问题：

HashMap为什么是不安全的？

当多线程时，线程a，b对同一位置进行插入元素，当a获取到这个位置的地址，准备插入时，时间片用完了，现在轮到b插入，b它处理快，直接插入成功了，现在a开始插入，就覆盖了b的数据。

 

当需要扩容时，两个线程同时对hashmap进行扩容，会导致产生循环链表

 

所以为了安全性问题，我们有了concurrenthashmap