1. 简介

HashMap

Java中的HashMap是符号表的一种哈希实现（采用拉链法），HashMap用来存储键值对，键和值都可以为Null，其中键是唯一的。在Java7中的实现是用数组+链表，在Java8中的实现是数组+链表+红黑树。因为引进了红黑树的，所以Java8中的HashMap的查找效率提高了不少。以下的讲解的源码也是Java8的源码。

拉链法

  • 拉链法是一种处理哈希冲突的一种方法，其他的还有线性探测法、平方探测法、双散列法。
  • 拉链法将产生冲突的元素放在数组冲突位置上的一个存储结构上（一般是链表）

2. 实现

HashMap内部结构

  1. 在HashMap中，数组table的大小是2的n次幂。
  2. 当HashMap中的键值对数量超过threshold这个阈值时，需要对数组进行扩容。为了避免数组过小导致每个数组位置存储的链表过长或红黑树过大，导致查找效率低下。这其实是一种以空间换时间的方法。
  3. 当数组中的链表超过8时，将链表换成红黑树以提高查找效率。
HashMap内部结构图
HashMap内部结构图

属性

1
2
3
4
5
6
7
8
9
10
11
12
13
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; /默认初始容量
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; /由链表转换为红黑树时桶的阈值

transient Node<K,V>[] table;    
transient Set<Map.Entry<K,V>> entrySet;  
transient int size; /哈希表当前的键值对数量
transient int modCount; /哈希表内部结构发生变化的次数
int threshold;  /扩容的阈值
final float loadFactor; /负载因子

结点类型

在HashMap中存储的键值对都是Node或是Node的子类，链表的结点类型是Node，红黑树的结点类型是TreeNode。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash; /储存对key使用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;
    }

    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }

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

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (o == this)
            return true;
        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;
    }
}

构造函数

  • initialCapacity参数用来确定哈希表初始容量（桶的数量），不过并不直接使用initialCapacity来作为初始容量，而是使用由tableSizeFor方法来得出不小于initialCapacity的第一个2的n次幂的正整数（例如输入8返回8，输入9返回16）作为初始容量。
  • loadFactor用来指定负载因子

当构造函数执行完并不会创建Node的数组，而是等到put方法执行时由resize方法创建。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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);
}

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;
}

hash方法

进行查找操作最重要的一步就是确定键在哪个桶中，其中第一步就用到hash方法，使用到hash方法是为了使键在数组中的分布更加均匀，减少冲突：

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

接着利用(n - 1) & hash（n是数组table的大小）得出键在哪个桶中，那这里为什么不用hash % n呢？因为位运算的速度比求余快。这里的table的大小必须是2的n次幂，原因有两个：

  • 因为n - 1之后高位为0，低位部分为1，使得哈希方法结果在参与与运算之后有意义，从而减少冲突。
  • 为之后的扩容方法做优化

put方法

数组table就是第一次执行put方法时创建出来的。

put方法执行流程图

put方法执行流程图
put方法执行流程图

源码分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
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;
    
    /数组还没创建或者数组大小为0
    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 {
        /e是用来存储找到的结点
        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)
            /调用putTreeVal方法向该树插入该结点，如果返回为空则插入成功，否则在树中找到该结点
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            /遍历该桶的链表
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    /当发现下个结点为空，证明已经遍历完所有结点还没发现key所在的结点
                    那就直接插入新结点
                    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;
            /如果允许结点存在时替换旧的值或者旧的值为null则替换旧值
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

扩容方法

Java 1.8里的扩容方法比较特别的一个优化就是扩容后结点的转移，例如对于原数组的一个桶中的所有元素要转移到新数组中需要一个个重新用hash & (n - 1)计算新位置吗？当然不用。得益于数组大小的特点（2的n次幂），我们可以轻易知道原数组的一个桶中所有结点转移到新数组中只会存在于两个位置：

  • 原索引
  • 原索引 + oldCap
    image
    image

关于这个的原理观察一下这个hash & (n - 1)和上图你就能发现扩容后改变的是n，而与hash进行与运算的n - 1比原来多了一位1，与运算后出来的索引比原来多一种可能，而这种可能就是在原索引的基础上加上oldCap。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    /若原数组的大小已经大于0
    if (oldCap > 0) {
        / 若原数组大小已经达到最大值，则设置阈值为Integer.MAX_VALUE，即以后不能再执行扩容方法
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }/否则将数组扩大一倍，
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            /扩容后数组的大小未达到最大值并且旧数组大小不小于默认初始容量则将阈值也扩大一倍
            newThr = oldThr << 1; 
    }/否则如果旧阈值大于0（即在构造函数中给出了initialCapacity）
    else if (oldThr > 0) 
        newCap = oldThr;
    else {
        /未给定initialCapacity就使用默认初始容量，阈值也是默认的
        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;
    @SuppressWarnings({"rawtypes","unchecked"})
        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;
                /否则如果结点是TreeNode类型，执行split方法
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    /两条链表
                    第一条是代表原索引位置上的链表
                    第二条是代表原索引 + oldCap位置上的链表
                    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;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

树形化

当添加一个结点后如果结点所在链表的长度大于8时，要将链表树形化（转换为红黑树）。但是进行树形化还需要满足一个条件，就是数组的大小要不小于MIN_TREEIFY_CAPACITY。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
    }

remove方法

remove方法执行过程图

remove方法执行过程图
remove方法执行过程图

源码分析

  • matchValue是一个布尔型参数，为false表示不需要匹配值，为true表示需要匹配值，值一样才算找到
  • movable表示移除红黑树结点时需不需要移动其他结点
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

    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);
                }
            }
            /结点不为空则为找到
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                else if (node == p)
                    tab[index] = node.next;
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

迭代器

在HashMap里一共有三种迭代器：

  • KeyIterator
  • ValueIterator
  • EntryIterator

这三种迭代器都继承了HashIterator类并实现了Iterator接口供KeySet、Values、EntrySet使用。其中最重要的HashIterator是用来迭代哈希表中的结点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
abstract class HashIterator {
    Node<K,V> next;        // next entry to return
    Node<K,V> current;     // current entry
    int expectedModCount;  // for fast-fail
    int index;             // current slot

    HashIterator() {
        expectedModCount = modCount;
        Node<K,V>[] t = table;
        current = next = null;
        index = 0;
        /找到第一个不为空的桶
        if (t != null && size > 0) { // advance to first entry
            do {} while (index < t.length && (next = t[index++]) == null);
        }
    }

    public final boolean hasNext() {
        return next != null;
    }

    final Node<K,V> nextNode() {
        Node<K,V>[] t;
        Node<K,V> e = next;
        /如果modCount != expectedModCount则表示可能有其他线程修改了哈希表或者当前线程调用非迭代器的方法修改
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        if (e == null)
            throw new NoSuchElementException();
        /设置current为当前结点并找到下一个结点赋值给next
        if ((next = (current = e).next) == null && (t = table) != null) {
            do {} while (index < t.length && (next = t[index++]) == null);
        }
        return e;
    }

    public final void remove() {
        Node<K,V> p = current;
        if (p == null)
            throw new IllegalStateException();
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        current = null;
        K key = p.key;
        removeNode(hash(key), key, null, false, false);
        expectedModCount = modCount;
    }
}

在HashMap中的modCount是和迭代器中expectedModCount搭配起来提供快速失败机制（fail-fast）的。 体现在用迭代器遍历HashMap时，如果遍历过程中对集合对象的内容进行了修改，可能会导致迭代器遍历出现异常。所以每次使用next、remove方法都会先判断modCount与expectedModCount是否相等，如果不相等则表示被修改过，就会抛出ConcurrentModificationException。在迭代器遍历HashMap时如果想移除遍历到的值可以使用Iterator的remove方法。

3. 最后

  1. HashMap是无序的，即无法维持键值对的先后插入顺序，也无法提供按键排序的功能，如要使用有序的map（符号表），可以使用下面两种：
    • LinkedHashMap：LinkedHashMap是HashMap的子类，可以保证插入的先后顺序，用迭代器遍历LinkedHashMap时，先得到的记录是先插入的，也可以在构造时指定参数，按照访问次序进行排序。
    • TreeMap: TreeMap实现SortedMap接口，可以把记录按键的大小排序，默认是升序排序，也可以指定比较器进行排序，当用迭代器遍历TreeMap时，得到的记录是排过序的。
  2. HashMap不是线程安全的类，不能适用于多线程的环境。不过有三种方式使用线程安全的map（符号表）：
    • Hashtable： 已过时的类不推荐使用。
    • ConcurrentHashMap：推荐使用，使用CAS机制使得并发情况下效率比Hashtable高
    • Collections.synchronizedMap(map)：使用静态工厂方法将HashMap对象封装成一个线程安全的类，因为SynchronizedMap使用了synchronized关键字，所以并发效率不如ConcurrentHashMap高。