从Java源码探索哈希表的前世今生

哈希表的概述

哈希表是一个常见的数据结构，哈希表最大的优点是高效，在哈希表里面进行插入、删除或查找一个元素都只要O(1)的时间。因此，哈希表经常被用来优化时间效率。

在Java中，哈希表有两个对应类型，即HashSet和HashMap。

如果每个元素只有一个值，则用HashSet。例如HashSet在图搜索时经常用来存储已经搜索过的节点。

如果每个元素都存在一个值到另一个值的映射，那么就用HashMap。例如，如果不仅要存储一个文档中左右的单词，同时还关心每个单词在文档中出现的位置，则可以考虑使用HashMap，使用单词作为HashMap的键而位置作为值。

设计哈希表的前提是待存入的元素需要一个能计算自己哈希值的函数。在Java中所有的类型都集成了Object，每个Object的实例都可以通过重写hashCode方法来计算hash值。哈希表根据每个元素的哈希值把他存到合适的位置（计算下标）。

哈希表最重要的特点就是高效，只需要O(1)的时间就可以把一个元素存入或者读出。在常用的基础数据结构中，数组满足这个要求。因此，可以考虑基于数组实现哈希表。

把哈希值转换成数组下标可以采用的方法是对数组的长度取余，能够保证求出的下标小于数组的长度。例如数组长度为4，待存元素的哈希值为5，由于5除以4的余数为1，所以把他存到下标为1的位置。同理，待存元素的哈希值为2和3，则把他们存到数组下标为2和3的位置。

再存入一个哈希值为7的元素，由于7除以4的余数为3，因此应该存放到下标为3的位置。但原本数组下标为3的位置已经被哈希值为3的元素占用，所以此时就发生和哈希冲突或者哈希碰撞。哈希冲突是不可避免的。

为了避免这种冲突，可以把存入数组同一个位置的多个元素用链表存储。也就是说，数组中的每个位置对应的不是一个元素，而是一个链表。哈希值为3和7的元素都存放在数组下标为3的位置，因此，实际上他们存入了同一个链表之中。

接下来考虑如何判断哈希表中是否包含一个元素。例如为了判断哈希表中是否包含哈希值为7的元素，由于7除以4的余数是3，因此先找到数组下标为3的位置对应的链表，然后从头到尾扫描这个链表查看是否有哈希值为7的元素。但是在链表中扫描的时间复杂度为O(n)，链表越长查找需要的时间就越长。这就违背了设计哈希表最重要的一个初衷：存入和读取一个元素的时间复杂度为O(1)。因此，必须确保链表的长度不能太长。

可以计算哈希表中元素的数目与哈希表的比值。显然，在数组长度一定的情况下，存入的元素越多，这个比值就越大；在存入元素数目一定的情况下，数组的长度越长，这个比值就越小。当哈希表中元素的数目与数组长度的比值超过某一个阈值时，就需要对数组进行扩容，通常是让数组的长度翻倍，然后把哈希表中每个元素根据新的数组长度重新计算下标，存入适当的位置。只要阈值设置的合理，哈希表中的链表就不会太长，仍然可以认为存入和读取的时间复杂度都是O(1)。

HashMap

1 HashMap概述

JDK 1.7和JDK 1.8之中，HashMap的实现有所不同。JDK 1.7中HashMap的实现方式为数组+链表，JDK 1.8中HashMap的实现方式为数组+链表+红黑树。因为链表的查询效率是O(n)，而红黑树的查询效率为O(log(n))。所以要在链表长度达到一定阈值的时候进行树化。有关红黑树的相关资料请见数据结构之红黑树。树化本身是非常耗时的，而对红黑树的插入操作也很不便，所以我们在使用HashMap的时候要尽量的避免树化。

2 HashMap的构造函数

阿里规约要求在使用HashMap的时候要传入初始化容量，这个容量要求是2的n次幂（为什么要求是2的次幂？）。但即使不传入，HashMap也有默认的初始化容量16。

/**
 * The javadoc description is true upon serialization.
 * Additionally, if the table array has not been allocated, this
 * field holds the initial array capacity, or zero signifying
 * DEFAULT_INITIAL_CAPACITY.
 * 此变量用于初始化数组，如果未被显示分配值，则默认为DEFAULT_INITIAL_CAPACITY
 */
int threshold;

/**
 * The default initial capacity - MUST be a power of two.
 * 默认的初始化容量 16
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

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;
    // 阈值会通过initialCapacity被初始化为2的次幂，但并不是真正用于数组初始化的阈值，它还会在put方法中进行再处理
    this.threshold = tableSizeFor(initialCapacity);
}

/**
 * 默认加载因子为0.75
 */
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

/**
 * 默认初始化容量为16，默认加载因子为0.75
 */
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
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

即使传入的不是2的n次幂，HashMap也会自动将传入的这个容量置为最近的2的次幂。方法如下：

/**
 * 此方法返回一个距离cap最近的2的次幂
 * 这个方法在不同的JDK版本实现不同，此版本为JDK 1.8实现版本，在以后的JDK中，会通过Integer提供的方法进行实现
 */
private static final int tableSizeFor(int cap) {
    int n = c - 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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3 HashMap的hash计算和下标计算

先来看一下put方法：

/**
 * The table, initialized on first use, and resized as necessary. When allocated, length is always a power 
 * of two. (We also tolerate length zero in some operations to allow bootstrapping mechanics that are not   
 * needed.)
 * 此数组在首次使用的时候才会被初始化
 */
transient Node<K,V>[] table;

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

/**
 * 扩容的方法
 * 同时也负责初始化数组
 */
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;
        }
        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;
    @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;
                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;
}
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

通过代码可知，只有在put第一个数据的时候，才会创建数组，并赋给成员变量table。

put方法中是这样计算下标的：(p = tab[i = (n - 1) & hash]) == null，其中n = tab.length，即是数组的长度。之前说过，HashMap中保证了数组的长度一定是2的次幂，则n - 1的二进制低位必定全部为1（特殊情况除外）。例如16 - 1的32位二进制表示为0000 0000 0000 0000 0000 0000 0000 1111，然后将这个二进制数与hash值进行与运算，那么结果必定只保留低位部分，所以与运算的结果必定会在0 到 n - 1之间，即保证了下标运算的结果不会越界。通过位运算，比取余运算效率高很多。

HashMap的hash值又是怎么计算的呢？

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

当key为null的时候，hash值为0；当key不为null的时候，先取key的hashCode（hashCode是一个int值），然后将这个hashCode无符号右移16位，然后将右移过后的值与原值进行与运算，将计算结果作为最终的hash值。

这样计算hash值的好处是，hashCode值经过无符号右移之后，原来的高16位会与低16为进行与运算。因为在计算下标的时候，总是将hash值的低位用于计算，高位往往与上0得0，使得高位对数组下标的计算几乎没有影响。经过新的hash方法的右移和与运算之后，原hash值的高位和低位都可以对下标的计算结果产生影响了，这使得hash冲突产生的概率大大的降低了，数组的下标分布更加均匀。

4 HashMap扩容与树化

先来看一下树化的方法：

/**
 * The smallest table capacity for which bins may be treeified.
 * (Otherwise the table is resized if too many nodes in a bin.)
 * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
 * between resizing and treeification thresholds.
 * 树化所需要的最小的数组容量
 * 若树化之前发现数组容量小于64，则会有限扩容而不是树化
 */
static final int MIN_TREEIFY_CAPACITY = 64;

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

树化的方法首先判断数组的长度是否小于64，若小于64则优先扩容而不是树化；若数组长度大于64才会树化。

扩容的时机：

1. 数组的元素数目size > threshold，即size > 数组容量 * 加载因子。
2. 链表的长度大于等于8，且数组容量小于64

树化的时机：

1. 链表的长度大于等于8，且数组容量大于等于64

扩容的过程：

1. 创建新数组，容量是旧数组的二倍
2. 将所有元素重新计算下标，放入新数组中

树化的过程：

1. 把所有的Node都转化为TreeNode
2. 调用treeify()方法进行树化

总结：HashMap的扩容与树化都要对所有元素节点进行操作，所以是非常耗时的。HashMap计算hash和数组下标的方法保证了数组下标分配的均匀性，链表长度出现的概率符合泊松分布。在实际使用中，除非数据量特别巨大，否则一般不会出现树化。

5 HashMap的put过程

HashTable与HashMap的区别

1 继承父类不同

• HashTable继承自Dictionary类
• HashMap继承自AbstractMap类

2 线程安全性

• HashTable里面所有的方法都添加了synchronized，所以是线程安全的。故HashTable更适用于多线程环境。
• HashMap没有添加synchronized，所以是线程不安全的。故HashMap更适用于单线程环境。

3 空值支持不同

• HashTable对value的空值进行判断，如果value为空则直接抛出NullPointerException，同时没有对key进行空值处理。所以key和value都不支持空值
• HashMap的key和value都支持空值

4 初始化容量不同

• HashTable默认初始化容量为11，在构造函数中就将数组创建，属于饿汉式。
• HashMap默认初始化容量为16，且在第一次put元素的时候才创建数组，属于懒汉式。

5 扩容方式不同

• HashTable每次扩容为原来容量的二倍加1
• HashMap每次扩容为原来的二倍

6 计算hash值和数组下标的方式不同

• HashTable直接使用key.hashCode()作为hash值，通过hash值对数组长度取余计算对应的数组下标。
• HashMap对key.hashCode()进行高低位与运算来计算hash值，通过数组长度 - 1 与上 hash值来计算数组下标，效率更快。