Java8系列之重新认识HashMap

一.（1）Map接口：HashMap、HashTable、TreeMap和LinkedHashMap；

（2）HashMap不是线程安全的，继承abstractMap接口。

（3）HashTable是线程安全的，继承Dictionary接口。

二.JDK1.8对HashMap底层的实现进行了优化，引入红黑树的数据结构和扩容的优化等。

各个实现类的特点：

（1）HashMap：它根据键的hashCode值存储数据，大多数情况下可以直接定位到它的值，因而具有很快的访问速度。HashMap最多只允许一个键为null，但允许多个值为null。HsahMap非线程安全；如果需要满足线程安全，可以用Collections的synchronizedMap方法使HashMap具有线程安全的能力，或者使用ConcurrentHashMap类。

（2）HashTable跟HashMap相似，不同的是它继承自Dictionary类，并且线程安全，并发性能不如ConcurrentHashMap。

（3）LinkedHashMap：LinkedHashMap是HashMap的一个子类，保存了记录的插入顺序，在用Iteraotr遍历LinkedHashMap时，先得到的记录是先插入的，也可以在构造时带参数，按照访问次序排序。

（4）TreeMap：TreeMap实现了SortedMap接口，能够把它保存的记录根据键排序，默认值是按键值的升序排序。

三.HashMap内部实现

（1）HashMap是什么？即它的存储结构——字段

（2）HashMap有什么作用？即它的功能实现——方法

（1.1）存储结构——字段

从结构实现：HashMap是数组+链表+红黑树实现

（1.1.1）HashMap类中的主要字段，Node[]table，即哈希桶数组，一个Node数组。

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;    //用来定位数组索引位置
        final K key;
        V value;
        Node<K,V> next;   //链表的下一个node

        Node(int hash, K key, V value, Node<K,V> next) { ... }
        public final K getKey(){ ... }
        public final V getValue() { ... }
        public final String toString() { ... }
        public final int hashCode() { ... }
        public final V setValue(V newValue) { ... }
        public final boolean equals(Object o) { ... }
}

Node是HashMap的一个内部类，实现了Map.Entry接口，本质上就是一个映射（键值对）。每个黑色圆点就是一个Node对象。

（1.1.2）HashMap就是哈希表来存储的。Java中HashMap采用了链地址法。链地址法，就是数组加链表的结合。在每个数组元素上都一个链表结构，当数据被Hash后，得到数组下标，把数据放在对应下标元素的链表上。

map.put("美团","小美");

put方法存储的过程：系统调用“美团”这个key的hashCode（）方法得到其hashCode值，然后再通过Hash算法的后两步运算（高位运算和取模运算）来定位该键值对的存储位置，有时两个key会定位到相同的位置，表示发生Hash碰撞。当然Hash算法计算结果越分散均匀，Hash碰撞的概率就越小，map的存取效率就会越高。

通过什么方式来控制map使得Hash碰撞的概率又小，哈希桶数组占用空间又少呢？使用好的Hash算法和扩容机制。

HashMap的默认构造函数源码：

int threshold;                  //所能容纳的key—value对最大值

final float loadFactor;   //负载因子

int modCount;

int size;

各个字段的意思：

threshold和loadFactor字段：Node[]table的初始化长度length（默认值是16），Loadfactor为负载因子（默认值为0.75），threshold是HashMap所能容纳的最大数据量的Node（键值对）个数。threshold=length*loadFactor。在数组定义好长度后，负载因子越大，所能容纳的键值对个数越多。threshold就是在此Load Factor和length（数组长度）对应下允许的最大元素数据，超过这个数目就重新resize，扩容后的HashMap容量是之前容量的两倍。

size：HashMap中实际存在的键值对数量。

modCount：记录HashMap内部结构发生变化的次数，主要用于迭代的快速失败。

在HashMap中，哈希桶数组table的长度length大小必须为2的n次方。

当链表长度太长（默认超过8）时，链表就转换位红黑树，利用红黑树快速增删改查的特点提高HashMap的性能。

功能实现—方法

主要讲解根据key获取哈希桶数组索引位置，put方法的详细执行、扩容过程。

（2.1）HashMap定位数组索引位置，直接决定了hash方法的离散性能。

方法一：

static final int hash(Object key){

int h;

//h=key.hashCode(); 第一步，取hashCode值

//h^(h>>>16);第二步，高位参与运算

return (key==null)?0:(h=key.hashCode())^(h>>>16);

}

方法二：

static int indexFor(int h,int length){

return h&(length-1);//取模运算

}

Hash算法本质：取key的hashcode值，高位运算、取模运算

方法一：对计算所得的hash值对数组长度取模运算。

方法二：该对象应该保存在table数组的哪个索引处。通过h&(table.length-1)来得到该对象的保存位，而HashMap底层数组的长度总是2的n次方，h&(table.length-1)运算等价于对length取模，&比%具有更高的效率。

（2）分析HashMap的put方法

a.判断键值对数组table[i]是否为空或为null，否则执行resize（）进行扩容；——是否扩容的判断

b.根据键值对key计算hash值得到插入数组索引i，如果table[i]==null,直接新建节点添加，转向f，如果table[i]不为空，转向c；——是否有重复索引的判断

c.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向d，这里的相同指的是hashCode以及equals；——判断是否有相同的key

d.判断table[i]是否为treeNode，即table[i]是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向e;——判断是否为红黑树

e.遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，遍历过程中若发现key已经存在直接覆盖value即可——判断链表长度是否大于8

f.插入成功后，判断实际存在的键值对数量size是否超过了最大容量threshold，如果超过，进行扩容。——判断是否要扩容

 1 public V put(K key, V value) {
 2     // 对key的hashCode()做hash
 3     return putVal(hash(key), key, value, false, true);
 4 }
 5 
 6 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 7                boolean evict) {
 8     Node<K,V>[] tab; Node<K,V> p; int n, i;
 9     // 步骤①：tab为空则创建
10     if ((tab = table) == null || (n = tab.length) == 0)
11         n = (tab = resize()).length;
12     // 步骤②：计算index，并对null做处理 
13     if ((p = tab[i = (n - 1) & hash]) == null) 
14         tab[i] = newNode(hash, key, value, null);
15     else {
16         Node<K,V> e; K k;
17         // 步骤③：节点key存在，直接覆盖value
18         if (p.hash == hash &&
19             ((k = p.key) == key || (key != null && key.equals(k))))
20             e = p;
21         // 步骤④：判断该链为红黑树
22         else if (p instanceof TreeNode)
23             e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
24         // 步骤⑤：该链为链表
25         else {
26             for (int binCount = 0; ; ++binCount) {
27                 if ((e = p.next) == null) {
28                     p.next = newNode(hash, key,value,null);
                        //链表长度大于8转换为红黑树进行处理
29                     if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st  
30                         treeifyBin(tab, hash);
31                     break;
32                 }
                    // key已经存在直接覆盖value
33                 if (e.hash == hash &&
34                     ((k = e.key) == key || (key != null && key.equals(k))))                                          break;
36                 p = e;
37             }
38         }
39         
40         if (e != null) { // existing mapping for key
41             V oldValue = e.value;
42             if (!onlyIfAbsent || oldValue == null)
43                 e.value = value;
44             afterNodeAccess(e);
45             return oldValue;
46         }
47     }

48     ++modCount;
49     // 步骤⑥：超过最大容量 就扩容
50     if (++size > threshold)
51         resize();
52     afterNodeInsertion(evict);
53     return null;
54 }

线程安全性

在多线程使用场景中，尽量避免使用线程不安全的HashMap，而使用线程安全的ConcurrentHashMap。