Java HashMap源码分析

HashMap源码分析

概述

• 在JDK1.7中，HashMap的数据结构为：数组+链表
• 在JDK1.8中，HashMap优化了数据结构，引入了红黑树，即：数组+链表+红黑树
• 解决hash冲突问题：
  • 无冲突：存放在数组中
  • 有冲突，链表长度<8时，存放在单链表中
  • 有冲突，链表长度>8时，先存入链表，再链表转红黑树

哈希表和哈希桶

• 采用哈希函数将记录储存在一块连续的存储空间中，这块连续的储存空间就称之为哈希表
• 哈希桶是解决哈希表冲突的一种方法，哈希表中同一个位置可能存有多个元素，为应对哈希冲突问题，将哈希表中的每个位置表示一个哈希桶

红黑树

• 链表不支持随机存取，只能单向遍历，效率很低，如果冲突比较严重，同一个index上的节点很多，那么链表就会很长，此时查找效率就会很低

• 使用红黑树，可以将查找效率由原来的线性时间变为对数时间，也就是O(n)变为O(logn)，所以为了效率问题， 这里直接使用了红黑树，也就是二分的思想。冲突越严重，红黑树的效果就越明显，比如链表长度为1024时，采用链表的效率就是1024，而红黑树就是log(1024)=10，差了100倍!

数据结构

储存流程

源码分析

HashMap类简介

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

基本属性

//默认初始容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

//最大容量，2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;

//默认负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;

//链表阀值，超过8转红黑树
static final int TREEIFY_THRESHOLD = 8;

//红黑树阀值，小于6转链表
static final int UNTREEIFY_THRESHOLD = 6;

//HashMap容量大于64才允许树化
static final int MIN_TREEIFY_CAPACITY = 64;

//hash桶数组
transient Node<K,V>[] table;

//负载因子
final float loadFactor;

//阀值，threshold=哈希表长度*负载因子，哈希表内元素超过阀值会扩容resize()
int threshold;

//元素数量
transient int size;

Node

Node是HashMap的一个内部类，用于存储key-value值，Node是一个单链表结构

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }
}

构造函数

HashMap在初始化的时候会定义初始容积和负载因子。

//无参构造函数，设置默认负载因子
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; 
}

//指定容量
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

//指定容量和负载因子
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);
}

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

put()

HashMap调用put()方法，会先将key值转hash值，通过二次哈希算法（高位运算和取模运算，目的是分散均匀，避免hash冲突），通过hash值计算存储位置。如果没有hash冲突，则将value值存放在指定位置，如果存在hash冲突，则尾插法放入单链表中，当单链表长度大于8时会转红黑树。
JDK1.8中是尾插法，JDK1.7是头插法。

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

//二次hash算法生成hash值，高位运算和区别运算，均匀分布避免hash冲突
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

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()创建
    //所以哈希表的创建是在第一次调用put()时
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;

    //插入值，会先判断是否有hash冲突
    
    //如果没有hash冲突
    if ((p = tab[i = (n - 1) & hash]) == null)
        //通过hash值找到指定坐标，如果该坐标没有元素则直接插入
        tab[i] = newNode(hash, key, value, null);
    //如果有hash冲突
    else {
        Node<K,V> e; K k;

        //如果hash值、key引用地址、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) 
                        treeifyBin(tab, hash);
                    break;
                }
                
                //查找到相同的key值
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                
                //更新p指向下一个节点
                p = e;
            }
        }
        
        //新值覆盖旧值操作
        if (e != null) { 
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    
    ++modCount;
    
    //如果容量大于阀值，则resize()扩容操作
    if (++size > threshold)
        resize();
    
    afterNodeInsertion(evict);
    return null;
}

resize()

扩容操作

//resize使用情况：1.初始化哈希表，2.扩容
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) {
        //如果旧容量大于最大值，则不在扩容
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //如果旧容量小于最大值，则2倍扩容
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }

    //初始化哈希表
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    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;
    //创建新的哈希表
    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<K,V>)e).split(this, newTab, j, oldCap);
                
                //扩容操作，重新计算元素位置
                else { 
                    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;
                        }
                        //原索引+oldCap
                        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;
                    }
                    //原索引+oldCap放入哈希桶里
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}