一.(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。