首先我们来看看Map的框架图
一、Map基本概述
Map是(Key-Value)键值对映射的抽象接口;AbstractMap实现了Map中的大部分方法接口,减少了Map的实现类的重复编码;SortMap为有序的键值对的映射接口;NavigableMap是继承于SortedMap的,支持搜索元素的接口。
HashMap、Hashtable、TreeMap、WeakHashMap为Map的实现类。
HashMap是基于拉链法实现的散列表(链表+数组),一般用于单线程中;
Hashtable基于拉链法实现的散列表(链表+数组),一般用于多线程;
WeakHashMap基于拉链法实现的散列表((链表+数组)),一般用于单线程中。
TreeMap是有序的散列表(链表+数组),是通过红黑树实现的。一般用于单线程中。
二、HashMap与Hashtable的异同
HashMap与Hashtable的相同点
HashMap和Hashtable底层都是散列表(链表+数组),并且都是采用拉链法来实现的。
存储的思想:通过table数组存储,数组的每一个元素都是一个Entry,而每一个Entry都是一个单向链表,Entry链表中的每一个节点就保存了key-value键值对数据。
添加元素时,首先根据key值计算出哈希值,再计算出数组索引,然后根据数组索引找到Entry(单向链表),再遍历单向链表,将key和链表中的每一个节点的key进行对比。若key已经存在Entry链表中,则用该value值取代之前的value值;若key不在Entry链表中,则新建一个key-value节点,并将该节点插入Entry链表的表头位置。
删除元素时,首先根据key值计算出哈希值,再计算出数组索引,然后根据索引展出Entry(单向链表),若节点key-value存在于链表Entry中,则删除链表中的节点。
HashMap与Hashtable的相同点
1、继承和实现方式不同
HashMap继承于AbstractMap,实现了Map、Cloneable、java.io.Serializable接口。
Hashtable继承于Dictionary,实现了Map、Cloneable、java.io.Serializable接口
区别在于HashMap继承了AbstractMap,而Hashtable继承了Dictionary。下面简单讲解:
Dictionary是一个抽象类,它直接继承于Object类,没有实现任何接口。Dictionary类是JDK1.0时引入的,尽管支持add()、get()、size()等方法,但其API没有Map多。Dictionary一般是通过Enumeration(枚举类)去遍历,Map则是通过Iterator(迭代器)去遍历。然而,由于Hashtable也实现了Map接口。因此枚举类遍历和迭代遍历都可以。
AbstractMap为一个抽象类,它实现了Map接口的绝大部分API方法。
2、线程安全不同
Hashtable是同步的,即是线程安全的,一般用于多线程环境下。
HashMap是非同步的,即不是线程安全的,若要在多线程中使用HashMap,需要进行的额外的同步处理,比如使用synchronizedMap静态方法,或者使用java.util.concurrent包里的ConcurrentHashMap。
3、对null值的处理不同
HashMap的key、value都可以为。
Hashtable的key、value都不可以为null。
注意两者添加元素的方法:
HashMap添加元素
// 将“key-value”添加到HashMap中
public V put(K key, V value) {
// 若“key为null”,则将该键值对添加到table[0]中。
if (key == null)
return putForNullKey(value);
// 若“key不为null”,则计算该key的哈希值,然后将其添加到该哈希值对应的链表中。
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
// 若“该key”对应的键值对已经存在,则用新的value取代旧的value。然后退出!
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 若“该key”对应的键值对不存在,则将“key-value”添加到table中
modCount++;
addEntry(hash, key, value, i);
return null;
}
// putForNullKey()的作用是将“key为null”键值对添加到table[0]位置
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
// recordAccess()函数什么也没有做
e.recordAccess(this);
return oldValue;
}
}
// 添加第1个“key为null”的元素都table中的时候,会执行到这里。
// 它的作用是将“设置table[0]的key为null,值为value”。
modCount++;
addEntry(0, null, value, 0);
return null;
}
Hashtable添加元素
// 将“key-value”添加到Hashtable中
public synchronized V put(K key, V value) {
// Hashtable中不能插入value为null的元素!!!
if (value == null) {
throw new NullPointerException();
}
// 若“Hashtable中已存在键为key的键值对”,
// 则用“新的value”替换“旧的value”
Entry tab[] = table;
// Hashtable中不能插入key为null的元素!!!
// 否则,下面的语句会抛出异常!
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
V old = e.value;
e.value = value;
return old;
}
}
// 若“Hashtable中不存在键为key的键值对”,
// (01) 将“修改统计数”+1
modCount++;
// (02) 若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)
// 则调整Hashtable的大小
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
rehash();
tab = table;
index = (hash & 0x7FFFFFFF) % tab.length;
}
// (03) 将“Hashtable中index”位置的Entry(链表)保存到e中 Entry<K,V> e = tab[index];
// (04) 创建“新的Entry节点”,并将“新的Entry”插入“Hashtable的index位置”,并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。
tab[index] = new Entry<K,V>(hash, key, value, e);
// (05) 将“Hashtable的实际容量”+1
count++;
return null;
}
由上述代码可以得到:
Hashtable的key和value值都不允许为空,否则会抛出空异常;
HashMap的key和value值可以为空,当HashMap的key为null时,HashMap会将其固定的插入到table[0]的位置,当有多个key为null时,table[0]会保留最后插入的value,对前面的值进行覆盖。
4、支持的遍历种类不同
HashMap只支持迭代器(Iterator)遍历;
HashtablezhichEnumeration(枚举类)和Iterator(迭代器)两种方式遍历。
5、通过Iterator迭代器遍历时,遍历的顺序不同
HashMap是从前向后的遍历数组,再对数组具体某一项对应的链表,从表头开始遍历。
Hashtable是从前向后遍历数组,再对数组具体,某一项对应的链表,从表头开始进行遍历。
HashMap的实现方式
// 返回“HashMap的Entry集合”
public Set<Map.Entry<K,V>> entrySet() {
return entrySet0();
}
// 返回“HashMap的Entry集合”,它实际是返回一个EntrySet对象
private Set<Map.Entry<K,V>> entrySet0() {
Set<Map.Entry<K,V>> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}
// EntrySet对应的集合
// EntrySet继承于AbstractSet,说明该集合中没有重复的EntrySet。
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
...
public Iterator<Map.Entry<K,V>> iterator() {
return newEntryIterator();
}
...
}
// 返回一个“entry迭代器”
Iterator<Map.Entry<K,V>> newEntryIterator() {
return new EntryIterator();
}
// Entry的迭代器
private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
return nextEntry();
}
}
private abstract class HashIterator<E> implements Iterator<E> {
// 下一个元素
Entry<K,V> next;
// expectedModCount用于实现fail-fast机制。
int expectedModCount;
// 当前索引
int index;
// 当前元素
Entry<K,V> current;
HashIterator() {
expectedModCount = modCount;
if (size > 0) { // advance to first entry
Entry[] t = table;
// 将next指向table中第一个不为null的元素。
// 这里利用了index的初始值为0,从0开始依次向后遍历,直到找到不为null的元素就退出循环。
while (index < t.length && (next = t[index++]) == null)
;
}
}
public final boolean hasNext() {
return next != null;
}
// 获取下一个元素
final Entry<K,V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
// 注意!!!
// 一个Entry就是一个单向链表
// 若该Entry的下一个节点不为空,就将next指向下一个节点;
// 否则,将next指向下一个链表(也是下一个Entry)的不为null的节点。
if ((next = e.next) == null) {
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
current = e;
return e;
}
...
}
Hashtable的实现方式
public Set<Map.Entry<K,V>> entrySet() {
if (entrySet==null)
entrySet = Collections.synchronizedSet(new EntrySet(), this);
return entrySet;
}
private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return getIterator(ENTRIES);
}
...
}
private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
// 指向Hashtable的table
Entry[] table = Hashtable.this.table;
// Hashtable的总的大小
int index = table.length;
Entry<K,V> entry = null;
Entry<K,V> lastReturned = null;
int type;
// Enumerator是 “迭代器(Iterator)” 还是 “枚举类(Enumeration)”的标志
// iterator为true,表示它是迭代器;否则,是枚举类。
boolean iterator;
// 在将Enumerator当作迭代器使用时会用到,用来实现fail-fast机制。
protected int expectedModCount = modCount;
Enumerator(int type, boolean iterator) {
this.type = type;
this.iterator = iterator;
}
// 从遍历table的数组的末尾向前查找,直到找到不为null的Entry。
public boolean hasMoreElements() {
Entry<K,V> e = entry;
int i = index;
Entry[] t = table;
/* Use locals for faster loop iteration */
while (e == null && i > 0) {
e = t[--i];
}
entry = e;
index = i;
return e != null;
}
// 获取下一个元素
// 注意:从hasMoreElements() 和nextElement() 可以看出“Hashtable的elements()遍历方式”
// 首先,从后向前的遍历table数组。table数组的每个节点都是一个单向链表(Entry)。
// 然后,依次向后遍历单向链表Entry。
public T nextElement() {
Entry<K,V> et = entry;
int i = index;
Entry[] t = table;
/* Use locals for faster loop iteration */
while (et == null && i > 0) {
et = t[--i];
}
entry = et;
index = i;
if (et != null) {
Entry<K,V> e = lastReturned = entry;
entry = e.next;
return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);
}
throw new NoSuchElementException("Hashtable Enumerator");
}
// 迭代器Iterator的判断是否存在下一个元素
// 实际上,它是调用的hasMoreElements()
public boolean hasNext() {
return hasMoreElements();
}
// 迭代器获取下一个元素
// 实际上,它是调用的nextElement()
public T next() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
return nextElement();
}
...
}
6、容量的初始值和增加方式不同
HashMap默认的容量大小是16,增加容量时,原始容量的两倍;
Hashtable默认的容量大小是11;增加容量时,原始容量的2倍加1。
HashMap和Hashtable默认的加载因子0.75.
7、添加Key-Value时的hash值算法不同
HashMap添加元素时,是使用自定义的哈希算法。
Hashtable没有自定义哈希算法,而直接采用key的hashCode()。
HashMap添加元素时,是使用自定义的哈希算法。
static int hash(int h) {
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
// 将“key-value”添加到HashMap中
public V put(K key, V value) {
// 若“key为null”,则将该键值对添加到table[0]中。
if (key == null)
return putForNullKey(value);
// 若“key不为null”,则计算该key的哈希值,然后将其添加到该哈希值对应的链表中。
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
// 若“该key”对应的键值对已经存在,则用新的value取代旧的value。然后退出!
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 若“该key”对应的键值对不存在,则将“key-value”添加到table中
modCount++;
addEntry(hash, key, value, i);
return null;
}
Hashtable没有自定义哈希算法,而直接采用的key的hashCode()。
public synchronized V put(K key, V value) {
// Hashtable中不能插入value为null的元素!!!
if (value == null) {
throw new NullPointerException();
}
// 若“Hashtable中已存在键为key的键值对”,
// 则用“新的value”替换“旧的value”
Entry tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
V old = e.value;
e.value = value;
return old;
}
}
// 若“Hashtable中不存在键为key的键值对”,
// (01) 将“修改统计数”+1
modCount++;
// (02) 若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)
// 则调整Hashtable的大小
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
rehash();
tab = table;
index = (hash & 0x7FFFFFFF) % tab.length;
}
// (03) 将“Hashtable中index”位置的Entry(链表)保存到e中
Entry<K,V> e = tab[index];
// (04) 创建“新的Entry节点”,并将“新的Entry”插入“Hashtable的index位置”,并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。
tab[index] = new Entry<K,V>(hash, key, value, e);
// (05) 将“Hashtable的实际容量”+1
count++;
return null;
}
8、两者部分API不同
HashMap不支持contains(Object value)方法,没有重写toString()方法;
而Hashtable支持contains(Object value)方法,而且重写了toString()方法。
补充:两者使用场景总结
根据上述总结的特点,一般单线程环境下,使用HashMap;而多线程环境爱下,使用HashTable,当然,多线程环境下,也可以使用ConcurrentHashMap。
三、HashMap和WeakHashMap异同点
HashMap和WeakHashMap的相同点
HashMap和WeakHashMap底层都是散列表(链表+数组),存储的是key-value键值对;都继承于AbstractMap,实现Map接口;都包括四个构造函数,且参数一样;默认的初始容量都是16,默认的加载因子都是0.75;两者key和value都允许为null。
两者都是非同步的,即不是线程安全的。
HashMap和WeakHashMap的不同点
1、HashMap实现了Cloneable和Serializable接口, 而WeakHashMap没有。
HashMap实现Cloneable,意味着它能通过clone()克隆自己。
HashMap实现Serializable,意味着它支持序列化,能通过序列化去传输。
2、HashMap的键是强引用,而WeakHashMap的键是弱引用。
WeakReference的“弱键”能实现WeakReference对“键值对”的动态回收。当“弱键”不再被使用到时,GC会回收它,WeakReference也会将“弱键”对应的键值对删除。
文章只是作为自己的学习笔记,借鉴了网上的许多案例,如果觉得阔以的话,希望多交流,在此谢过…