HashMap源码分析

新开一个坑，希望能填满吧。

HashMap是什么？1.7跟1.8中的hashmap有啥区别？

通俗点讲，就是Entry的一个集合，entry是key+value的键值对；

底层呢，1.7是数组+链表；1.8改为数组+链表（链表容量大于8时会转为红黑树）。

1.7在扩容时，容易产生死循环，1.8不会；

1.8将hash算法简化了；

新节点插入链表时顺序不同，1.7是倒序，1.8因为需要遍历链表把链表改为红黑树，所以是正序。

。。。写了堆啥啊。。重头开始吧

1.HashMap参数解析：

// 初始容量，默认16；1<<4，位运算，结果是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大容量 2的30次方，因为resize扩容时会用到（扩容时必须是2的整数次方），所以没有用到Integer的最大值即0x7ffffff
//而且 如果构造时指定容量参数argument大于此值，argument也会被改为这个值
static final int MAXIMUM_CAPACITY = 1 << 30;
//加载因子：当实际size值大于容量*加载因子时，需要进行扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表转红黑树的阀值，链表长度达到此值时，会转成红黑树
static final int TREEIFY_THRESHOLD = 8;
//链表长度达到此值时，会由红黑树转为链表
static final int UNTREEIFY_THRESHOLD = 6;
//转变成树之前，还会有一次判断，只有键值对数量大于 64 才会发生转换。这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化
static final int MIN_TREEIFY_CAPACITY = 64;

//node数组，实际存放 键值对 的地方（Node是内部类，链表结构）
transient Node<K,V>[] table;
//遍历时使用的，用来缓存entrySet()方法
transient Set<Map.Entry<K,V>> entrySet;
//已使用的容量
transient int size;
//当前的最大容量
transient int modCount;
//加载因子 
final float loadFactor;

2.put

1.8的put方法看着着实比1.7的复杂，但其实业务逻辑没差啥，反而还是优化了不少

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //判断是否需要扩容
        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 存在，直接覆盖
            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);
                        //如果链表数大于8，进行插入红黑树节点操作
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //如果key存在，直接覆盖
                    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;
    }

结合源码，在看下面这张图，就很直观了

3.get

如果理解了hashmap的put方法里面的操作，那get方法就很容易理解了

通过传入的key，进行一个hash算法，找到key的hash值，那么通过这个hash值先找到数组的下标，进行一个判断，如果hash值跟equals方法都是true，说明这就是你想要的node，然后返回node.value就是你想要的value值；而如果下标对应的节点，是一个链表（node.next 不为空，说明是个链表），那么需要进行遍历，通过equlas方法找到对应的node，然后返回node.value

具体源码如下：

final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> 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<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

源码分析就先到这里，其中有很多很重要的原理东西，我还没整理完，回头慢慢补吧

不得不说，hashmap是一个很牛逼的东西，值得人们去了解里面的原理