HashMap1.8源码深入分析

在分析源码之前有必要先了解一下HashMap的数据结构

HashMap1.8是一种数组+链表+红黑树的数据存储结构。
数组的长度永远为2的次方，链表是为了解决hash冲突时，即多个key被计算到了同一个数组下标时，则以当前数组下标作为头结点，然后以链表的方式进行存储，当链表长度超过8时则转为红黑树，低于6时则再转为链表。

数据结构了解后再了解几个重要的属性

1、DEFAULT_INITIAL_CAPACITY
CAPACITY可以理解hashmap槽的数量，table长度，默认为16，且必须为2的次方。

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

2、DEFAULT_LOAD_FACTOR
加载因子，默认为0.75，主要作用是用来防止hash冲突过于严重。比如我们默认数组长度为16，当数组被使用达到16*0.75=12时，则对数组进行扩容为32。

static final float DEFAULT_LOAD_FACTOR = 0.75f;

3、链表与红黑树互相转换的阈值。

static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;

HashMap的几种构造方法

1、无参构造方法，也是我们最常用的方法
所有属性都为默认值

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

2、带初始容量，实际上调用了带初始容量、加载因子的构造方法

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

3、带初始容量和加载因子，有一些基本参数校验

public HashMap(int initialCapacity, float loadFactor) {
	//容量不能小于0
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
     //容量有最大值限制
     //static final int MAXIMUM_CAPACITY = 1 << 30;
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    //保证容量为2的次方，比如传入的是17~32，通过tableSizeFor方法实际上会得到32，传入33~64，会得到64，以此类推。
    this.threshold = tableSizeFor(initialCapacity);
}

4、直接通过一个map构造一个新的map。

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

put方法解析

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

static final int hash(Object key) {
    int h;
    //当key为null时，默认放到数组的第一个下标中。
    //其余通过key的hashCode与高16位进行异或运算，使得得到的结果能够更加散列
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
   /**
     * 源码中会出现大量的判断带赋值的方式。
     * 比如if ((tab = table) == null || (n = tab.length) == 0)，table赋值给了tab后再判断是否为null，tab.length赋值给了n再判断是否为0
     * 这与编码的习惯有关系，阅读时请注意
     */
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    /**
     * table即表示数组，如果我们使用的是无参的构造函数创建map对象，当我们第一次put时，要先对table进行初始化，
     * 也就是说我们的第一次初始化实际是在put时完成的.
     */
    if ((tab = table) == null || (n = tab.length) == 0)
        //resize重置table数组大小的方法，包含了初始化，扩容
        n = (tab = resize()).length;

    /**
     * 计算当前key应存放的数组下标的位置
     * 当数组长度为2的次方的时候， (n - 1) & hash == hash % n
     * 用位运算替代取模运算能够提高运算效率，这也是为什么要保持数组长度为2的次方的原因。
     */
    if ((p = tab[i = (n - 1) & hash]) == null)
        //当前数组下标为空，则直接创建一个新的node放到当前下标位置
        tab[i] = newNode(hash, key, value, null);
    else {
        //当下标位置已经有元素时。
        Node<K,V> e; K k;
        /**
         * 先判断当前key的hash值与下标位置key的hash值是否相等，如果相等再判断key是否相等或者equals。
         * 如果相等则直接赋值给 Node e。
         */
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            //如果当前节点是TreeNode类型，调用树结构的方式put
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                //依次拿到下一个节点，并判断是否为空
                if ((e = p.next) == null) {
                    /**
                     * 如果为空则创建一个新的node，并设置为当前节点的next节点.
                     * 并判断当前链表的长度是否超过阈值，如果超过则将链表转为红黑树结构。
                     */
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //如果不为空，则同样按照hash、key的方式判断是否是同一个元素
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        /**
         * 赋值value到node节点中，并返回旧的value值
         */
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            //LinkedHashMap的方法，支持排序的实现，hashmap只是一个空方法。
            afterNodeAccess(e);
            return oldValue;
        }
    }

    /**
     * 记录hashmap的修改次数，具体作用解释如下，确保当发生并发操作异常时快速失败。
     * This field is used to make iterators on Collection-views of the HashMap fail-fast
     */
    ++modCount;
    //能执行到这里，说明元素都是新的，原来map中并没有。
    //也就是说每新增一个map中没有元素时size就+1。
    if (++size > threshold)
        resize();
    //LinkedHashMap的方法，支持排序的实现，hashmap只是一个空方法。
    afterNodeInsertion(evict);
    return null;
}

get方法解析

public V get(Object key) {
    Node<K,V> e;
    //同put一样，先计算key的hash值
    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;
    /**
     * 如果数组不为空，并且key的下标位置不为空
     */
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        /**
         * 不同的key在大多数情况下hash都不相等。
         * 所以优先校验hash是否相等，可以有效的提高get的执行效率
         *
         * 之后的方法与put类似，无非就是从树结构或者链表结构中遍历比较，找到目标key
         */
        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;
}

无论是put方法还是get方法再比较key是否相等时，都时先判断hash是否相等，再判断key是否相等或者key是否equals，基于这样的方式，java中有这样一个约束，重新一个对象的equals的方法，也必须重写hashcode方法，假设你重写equals后，两个对象equals判断相等，但是hashcode却不相等，那么你依然不能get或者put到你想要的结果。

举一个小例子:

public class TestHash {

    public static void main(String[] args) {
        Map<User,Object> map = new HashMap<>();
        User u1 = new User("zs");
        User u2 = new User("zs");
        //两个对象equals相等
        System.out.println("u1 equals u2: " + u1.equals(u2));
        map.put(u1,"user");
        //get时却拿不到值
        System.out.println("map get result: " + map.get(u2));

    }
}

class User{
    private String name;

    public User(String name){
        this.name = name;
    }
	
	//没有按照标准的方法重写，但是不影响演示效果
    @Override
    public boolean equals(Object obj) {
        User user = (User) obj;
        if(user.name.equals(name)){
            return true;
        }
        return false;
    }
}

u1 equals u2: true
map get result: null

resize方法解析

final Node<K,V>[] resize() {
    //resize之前的table
    Node<K,V>[] oldTab = table;
    //resize之前的table容量
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //resize之前的扩容阈值，初始为table容量。
    int oldThr = threshold;
    int newCap, newThr = 0;
    //table容量不为空（扩容）
    if (oldCap > 0) {
        //table的容量最大值校验与设置
        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
    }
    //第一次put时的场景（初始化，使用有参构造函数创建的map）
    else if (oldThr > 0) // initial capacity was placed in threshold
        //给新的容量赋值
        newCap = oldThr;
    //第一次put时的场景（初始化，使用无参构造函数创建的map）
    else {               // zero initial threshold signifies using defaults
        //给容量和扩容阈值设置默认值
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //使用有参构造函数时，初始化扩容阈值，或者上面if (oldCap > 0)里面条件不满足
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        //控制扩容阈值的范围，最大为Integer.MAX_VALUE
        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;
    /**
     * 下面是把原table中的数据，重新计算后放入新的table中的算法过程。
     * 改善了1.7之前头插法在并发下可能会造成死循环的问题，改为尾插法
     * 利用原来的key要么在原来的下标位置，要么在原来的位置+原来table长度的位置，
     * 省去了原先一个个遍历key找下标位置的过程，提高了扩容效率
     */
    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;
}

HashMap1.8总结：

1、HashMap中强制设定table的长度必须为2的倍数，实现了一些优化的算法。

• 利用与运算代替取模：(n - 1) & hash == hash % n。
• 扩容时：原来的key要么在原来的下标位置，要么在原来的位置+原来table长度的位置。

2、改善了resize的方法，避免了之前版本并发时可能造成死循环的问题，但是HashMap依旧是线程不安全的，多线程并发下请使用线程安全的map，比如ConcurrentHashMap。

3、通过hash值来完成某些比较判断时，重写equals则必须重写hashcode方法，不然会造成两个对象equals相等，get时得到的结果却是null。

4、利用链地址法解决hash冲突的问题。

5、利用红黑树解决当链表地址过长时遍历的效率问题。

6、优化性能的小技巧，过滤概率高的优先判断。

if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))