HashMap源码解析

1.概述

HashMap是一种非线性安全、遍历无序、key和value均可为null的键值对集合。Hash是一种压缩映射算法，它是将任意大小的值映射到固定大小范围的值。HashMap在jdk 1.8后采用数组+链表+红黑树的数据结构实现。HashMap是一个容器，它的作用就是存东西，核心功能就是增删改查，自jdk 1.8后增加了红黑树结构，提高了增删改查的效率。

2.源码解析

2.1 构造函数

HashMap共有4个构造函数，仅用于初始化阈值和负载系数。其中阈值是可延迟初始化，负载系数是必定初始化。我们常用的是HashMap的无参构造器，只进行负载系数的初始化为0.75。我们在初始化时可以指定HashMap的K与V的具体类型。

/**
     *初始化hashMap的loadFactor与threshold参数
     */
    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 初始容量：这个初始容量和hashMap的容量没有关系，而是用于通过tableSizeFor方法计算阈值大小。
• loadFactor 负载系数：默认为0.75。用于计算阈值的一个固定参数。用于计算阈值进行判断是否扩容，计算公式：threshold=initialCapacity*loadFactor。
• threshold 阈值：因为在构造函数中没有初始化HashMap初始容量，所以计算阈值的方法是通过tableSizeFor方法，当前容量大于阈值后，hashMap会进行扩容。

/**
     * 对于给定的目标容量，返回最小大于等于指定容量的2的幂次
     */
    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;
    }

n |= n >>> 1的计算过程是n的2进制数a与a向右移一位数b进行或运算。若n>=0且n

2.2 Node节点

单链表结点，包含key的hash值、key、value和下一节点next，构造函数需要初始化这四个值。HashCode方法返回的值这个节点的hash值，他不是key的hash值。node的equals方法判断两个节点是否相等，满足两个节点key、value相等即可，不一定是同一节点。

    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash; //通过key计算的hash值
        final K key; 
        V value;
        Node<K,V> next;//下一结点
        
        //省略构造函数
        ...
        
        //每一个节点的hash值，是将key的hashCode 和 value的hashCode 通过异或运算得到
        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

		//给map结点设置新值，同时返回旧值
        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
		//判断是否与当前结点相等
        public final boolean equals(Object o) {
        	//1. 同一个
            if (o == this)
                return true;
            //2. 两个结点key与key，value与value相等
            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;
        }
    }

2.3 内部类相关

• KeySet
  keySet()方法返回包含这个map所有的key的set，这个set与map相关联，map的改动会影响set，反之亦然。由于map.keySet()返回的是KeySet内部类实现的Set，KeySet继承自抽象类AbstractSet，AbstractSet实现了Set接口，所以我们在调用map.keySet()的一些方法时需要注意有些抽象方法没有实现，使用会报错的，例如add()方法。
• Values
  values()方法返回的是map的所有value的集合，用法和属性与上面的Keyset很相似。同样不支持Add相关方法。
• EntrySet
  entrySet()方法返回的是将整个map的所有节点。set的元素是hashMap的一个节点。

2.4 TreeNode

这就是传说中红黑树结构的节点，这是jdk1.8引入的，所谓的红黑树本质上是一种二叉查找树，但它在二叉查找树的基础上额外添加了一个标记（颜色），同时具有一定的规则。这些规则使红黑树保证了一种平衡，插入、删除、查找的最坏时间复杂度都为 O(logn)。

	TreeNode<K,V> parent;  //父节点
    TreeNode<K,V> left;    //左节点
    TreeNode<K,V> right;   //右节点
    TreeNode<K,V> prev;    //前一个元素节点
    boolean red;           //节点是否标记为红色

因为TreeNode继承自LinkedHashMap.LinkedHashMapEntry，又LinkedHashMap.LinkedHashMapEntry继承自HashMap.Node，所以TreeNode具有他们的所有属性。
与红黑树相关有3个重要参数

• TREEIFY_THRESHOLD =8 单链表长度达到8会进行转换成红黑树

• UNTREEIFY_THRESHOLD =6 当红黑树的长度小于6红黑树结构会转换为单链表

• MIN_TREEIFY_CAPACITY =64 当哈希表的容量小于64时是不会单链表是不会转红黑树的，而是先把哈希表的容量扩容到大于64后，单链表才可以转红黑树。

   红黑树的内容现不做详解，日后在专门写一篇有关HashMa红黑树相关文章。
  

2.5 Hash算法

这是hashMap的hash算法，我们在向HashMap put 进来一个键值对的时候，会将key进行hash求得hash值存入hashMap节点中去。

static final int hash(Object key) {
        int h;
        //key为null，直接返回0
        //否则计算key的HashCode（详解1）为回h，计算h的二进制数右移16位与h异或
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

详解1，hashCode是Ocject类的方法，这个方法的作用是讲一个任意类型对象转化为一个int类型的数字。我们能够通过hashCode方法获得对象的Hash值，当向map存入键值对时会先比较hash值，若hash值相等再判断key是否相等。我们在计算一个对象的hash值的本质是将无限的对象映射到一个有限大小的int类型的集合中。这么做的用意是减少比较次数，提高查找效率。

2.6 put增加与修改

HashMap增加或者修改节点的方法，传入一个K 类型key和一个V类型value。HashMap中key是唯一的，当传入的key已存在时，会将新value替换就value。
简单的说，在HashMap 的put方法中会初始化Node数组，找到数组下标进行插入元素，插入分三种情况

• 单链表的头节点为空，将待插入的值赋给链表头节点。
• 待插入Node节点为TreeNode类型，进行红黑树插入。
• Node为单链表节点，在单链表结尾插入。

 public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    /**
     * @param key的hash值
     * @param key值
     * @param value
     * @param onlyIfAbsent 为true, value不可被更新
     * @param evict 为false,表为创建模式
     * @return 返回前一个的值，为空就返回none
     */
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
         //链表节点数组tab，用于存储所有单链表头节点
         //链表节点p
         //n为tab长度，i为待插入的tab下标
        
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //table是节点数组赋值给tab，
        if ((tab = table) == null || (n = tab.length) == 0)
        //resize方法用于初始化hashMap，返回hashMap的头节点
            n = (tab = resize()).length;
         //计算节点的插入下标i，i是n-1与hash进行二进制与运算。并将头节点赋值给p
         //详解1
        if ((p = tab[i = (n - 1) & hash]) == null)
         // 若当前节点为null，那么可以直接赋值，这是头节点赋值
            tab[i] = newNode(hash, key, value, null);
        else {
        //当头节点有值，e是待插入节点，k是待插入的key
            Node<K,V> e; K k;
            //头节点的hash与待插入的hash相等并且key相等
            //详解2
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //把p的值赋值给e
                e = p;
           //若p为TreeNode 类型，那么待插入节点用红黑树的插入方式插插入
           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);
                    //去掉头节点链表个数>=7,就会由单链表转成红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) 
                            treeifyBin(tab, hash);
                     //操作完毕，死循环终结
                        break;
                    }
                    //遍历过程中出现待插入的key已存在，就进行替换
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //当key已存在，就更新value
            //详解3
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                //详解4
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //插入完成后，当前容量达到阈值就进行扩容
        ++modCount;
        if (++size > threshold)
            resize();
         //详解4
        afterNodeInsertion(evict);
        return null;
    }

详解1: 计算待插入节点的数组下标i = (n - 1) & hash，n是数组长度，hash是待插入节点的key的hash值，n-1与hash进行按位与运算得到i为数组下标，这是put过程很关键一步，再次将庞大的hash值映射到小小的数组大小范围。
详解2: 这段代码在HashMap中很出现了多次，只要满足如下条件就说明我们key已存在，我们是在更改 value。待插入节点的key为基本类型时，比较key时用“==”，当key不为基本类类型，我们就得使用Object的equals方法进行比较，且key不能为null。

      if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))

详解3: 这里的e是经过比较确定与插入节点相等的节点，当满足e.value为空或者允许给value重新赋值，就可以给value进行赋值。
**详解4：**允许LinkedHashMap后处理的回调，在hashMap中没有实现，不会有任何操作，但是LinkedHashMap是继承自HahshMap，有重写这几个相关回调方法。当然我们也可以定义自己的Map继承HashMap并重写这几个方法。

2.7 resize初始化与扩容

HashMap中的resize方法很关键，他的作用是初始化和扩容，并为扩容后的HashMap的节点重新分配位置。

 final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;   //旧的头节点数组大小 
        int oldThr = threshold;								//旧扩容阈值
        int newCap, newThr = 0;
        //=====详解1=======
        if (oldCap > 0) {									//已初始化，进行扩容
            if (oldCap >= MAXIMUM_CAPACITY) {				//到达极限，不扩容
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&     //正常情况,数组大小乘2
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // 阈值乘2
        }
        else if (oldThr > 0)  //仅初始阈值，未初始化数组
            newCap = oldThr;
        else {               //完全未被初始化，就使用默认值初始化
            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);
        }
        //=====详解1=======
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
    //复制操作，详解2
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        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，详解3
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { 
                      //如果是链表，重新计算hash值，根据新的下标重新分组
                      //···
                      
                    }
                }
            }
        }
        return newTab;
    }

详解1: 判断扩容还是初始化，怎么初始化分三种情况。

• oldCap未当前数组大小，只要是他大于0，就说明HashMap的数组长度和扩容阈值都初始化了，在这里，会将数组长度与阈值都乘2（二进制右移一位）。但是扩容达到maxValue后就不会扩容了，但是这个maxValue为2^30，可以看作无限大。
• oldCap<=0且oldThr > 0，仅阈值初始化了未初始化数组，那么会将新数组大小设定为阈值大小，而新阈值大小会重新设定。
• 在这里初始化阈值大小和数组大小。

详解2: 头节点的数组大小扩容的实质就是，把几个参数翻一倍，再new一个更大头节点数组，把原本的数据再重新计算hash值，存入到新的结构中去，如果是树节点那么可能会调整结构。

2.8 get获取

这方法比较简单

//通过key查找value
public V get(Object key) {
        Node<K,V> e;
        //通过key的hash值与key获取node，再再通过node获取value
        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值确定头节点first
        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;
    }

2.9 remove移除

这个方法也比较简单，removeNode不止remove方法调用，matchValue为true时，value不匹配就不能删除。movable是在是在树remove节点时使用。

//通过key 移除数据
public V remove(Object key) {
        Node<K,V> e;
        //详解1
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }
    /**
    
     * @param key的hash
     * @param key
     * @param value 
     * @param matchValue 为true，remove的时候就需要匹配value了
     * @param 在树结构中使用，movable 为 true，remove操作后是整个节点删除，否则是将属性置为null
     */
    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 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            Node<K,V> 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<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);
                }
            }
            //找到node进行remove，并且不匹配value或者value相等
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                if (node instanceof TreeNode)   //树的remove node方法
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                else if (node == p)
                    tab[index] = node.next;
                else
                    p.next = node.next;    //node的前一个节点直接指向他后一个节点
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

3. 总结

HashMap作为面试必备知识点，详细分析是很有必要的。写这篇源码分析感觉有些吃力，有些地方我有些太过于纠结细节了，以至于有些地方条理不太清楚，日后会逐步完善。