HashMap原理及源码分析

本文源码分析基于JDK8

1. 存储结构

HashMap 的数据存储结构是一个 Node<K,V> 数组，在（Java 7 中是 Entry<K,V> 数组，但结构相同）

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    // 数组
   static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;//hash值
        final K key;//键
        V value;//值
        Node<K,V> next;//下一个结点

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

}

存储结构主要是数组加链表，像下面的图。

2. 属性

  static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //默认初始容量  必须是2的n次幂，存储高效，尽量减少碰撞，在（n-1)&hash求索引的时候更均匀
   static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量
    static final float DEFAULT_LOAD_FACTOR = 0.75f;//负载因子
    static final int TREEIFY_THRESHOLD = 8;//树化
    static final int UNTREEIFY_THRESHOLD = 6;//从树转化为链表
    static final int MIN_TREEIFY_CAPACITY = 64;//当数组长度为64时，并且链表长度大于8，才转化红黑树
    transient Node<K,V>[] table;//table用来初始化数组（大小是2的n次幂）
    transient Set<Map.Entry<K,V>> entrySet;//用来存放缓存（遍历的时候使用）
    transient int size;//HashMap中存放元素的个数（重点）
    transient int modCount;//记录HashMap的修改次数
    int threshold;//临界值（如果存放元素大小大于该值，则进行扩容）
    final float loadFactor ;//哈希表的加载因子（重点）

3.主要方法

1)hash值

是通过key.hashcode异或key.hashcode右移16位，高16位补0，因一个数和0异或不变，相当于key.hashcode的高16位不变，key.hashcode的低16位和key.hashcode的高16位进行了异或运算。因为bucket数组大小是2的幂，计算下标index=(table.length-1)&hash,如果不做hash处理，相当于只有散列生效的只有几个低bit位，为了减少哈希碰撞，使用高bit位和低bit位进行异或来处理减少哈希碰撞。

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

2）容量

如果传入的容量不是2的次幂，那么就进行下面操作，一共进行5次或运算，可以将当前数字中二进制最高位1的右边全部变成1，最后+1后返回

 static final int tableSizeFor(int cap) {
//这里-1的目的是使得找到的目标值大于或等于原值
        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;
    }

### 3)构造方法

//传入容量 负载因子
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(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}


public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // 传入负载因子
}

//默认负载因子 包含另一个Map的构造函数
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize();
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);
}
}
}

4）成员方法

1）先判断数组是否未初始化，如果没有初始化，则进行一次初始化操作（扩容），同时将数组大小赋给n

2）找到具体的桶，并判断此位置是否有元素，如果没有元素，则创建一个Node直接插入

3）如果出现冲突

​ 1）如果为红黑树节点，调用红黑树方法插入数据

​ 2）如果为普通节点，插入链表末尾，并且长度达到临界值时，将链表转为红黑树

  4）如果桶中存在重复的键，将该键替换新值value

  5）size大于阈值threshold，进行扩容

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

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;//声明tab 和Node数组
        if ((tab = table) == null || (n = tab.length) == 0)
    	//此处才进行tab的初始化。tab为空或者数组大小为0，对数组进行初始化操作，并将数组大小赋给n
            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;
            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;
    }