Map，中文名字映射，它保存了键-值对的一对一的关系形式，并用哈希值来作为存贮的索引依据，在查找、插入以及删除时的时间复杂度都为O(1)，是一种在程序中用的最多的几种数据结构。Java在java.util工具包中实现了Map接口，来作为各大Map实现类的规范，其中主要的Map实现类有三个，分别是：HashMap、TreeMap以及LinkedHashMap类，三者的关系如图所示：
先从Map接口说起，讨论其Java的Map规范以及实现的定义，在Map接口内，还定义了另外一个内部接口，该接口用来存贮键值对的，其源码如下：
interface Entry<K,V> {
K getKey();
V getValue();
V setValue(V value);
boolean equals(Object o);
int hashCode();
public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getKey().compareTo(c2.getKey());
}
public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getValue().compareTo(c2.getValue());
}
//......
}
从该内部接口的实现来看，它在比较键或值时，需要的实现了Comparable与Comparator接口的类，以此来比较，也就是说，我们在用Map接口实现类存贮自定义的对象时，最好实现这两个接口。通时，在定义增删查改的基础上，加了检查的一项：
//检查Map里缺少值的键，并将新值赋给该键
default V computeIfAbsent(K key,
Function<? super K, ? extends V> mappingFunction)
//检查Map里包含值的键，并把新值赋给键
default V computeIfPresent(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) ;
//这个方法是前两者的综合
default V compute(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) ;
HashMap
HashMap继承AbstractMap类，实现了Map、 Cloneable,、Serializable接口：
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable{
}
HashMap提供了4个构造器用于初始化：
//提供容量与负载因子的构造器
public HashMap(int initialCapacity, float loadFactor) {
//......
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
//提供容量的构造器
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//默认构造器
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
//提供自Map的gouzaoqi构造器
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
其中的loadFactor指的是负载因子，有的称加载因子，是用来当哈希桶容量不够时，扩展threshold 大小使用的，哈希桶是用来存放键值对的一个数组，其扩展的threshold 的大小是原来哈希桶容量 的大小乘以负载因子的。threshold 就是个门槛，是来判定什么时候需要扩展哈希桶的大小的，当哈希桶中存贮的元素多于threshold 值时，则需要进行桶容量的扩展，以此来优化hashMap的效率。其初始默认的桶容量、负载因子如下：
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//开始扩展桶容量的判断：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//......
if (++size > threshold)
resize();
//......
}
那么，hashMap怎么进行存贮键值对，而让其查找的时间复杂度为O(1)呢？是利用每个键的哈希值，在进行存贮的时候，先计算键的哈希值，通过哈希值来确定索引值，这样就可以完成时间复杂度为O(1)的操作：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
然而这样会引发一个危险的操作，因为哈希值是不确定的，桶的容量是有限的，怎么防止通过哈希值得到的索引值不越界，是通过位运算符来操作的：
iedex = (length - 1) & hash;
length代表着桶的容量，hash代表着键的哈希值，从桶容量的扩展可以看出，桶的容量始终是2n，减去1用二进制表示则是后n位全是1，前面都是0，这样就可以成功的保存后n位的哈希值，从而让它不产生越界的索引值。还有一个问题是，当键通过该方法产生的索引值一样，怎么解决这个键冲突，hashMap是采用经典的链表法来解决的，当产生的索引值上有数据时，便将该键链至当前索引值的键的next属性。在hashMap类中的Node节点用来保存键值对的数据：
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
//......
}
hashMap保存数据时，首先会将键值对插入桶中，然后检查容量是否到了threshold 门槛，到了则进行扩容，扩容的时候需要注意的是插入到新的桶中的元素处理，与刚开始插入旧桶里一样，计算键的哈希值并插入桶中：
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;
}
对于插入到桶中的元素，其操作策略是先判断桶的容量够不够，再进行插入操作：
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;
}
其中注意的是：
static final int TREEIFY_THRESHOLD = 8;
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
这句话的意思是如果某个桶中的元素超过了8个，那么就不再用链表法来解决键冲突，而是将整个链表转化成一个平衡二叉树来提升效率。树的节点定义如下：
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
}
HashMap里的平衡二叉树是由红黑树来实现的，限于篇幅原因就不再讲解树的知识（就是懒，23333）。
TreeMap
TreeMap类，如其名，是一个以树结构来实现Map的一个类，其中节点的定义如下：
static final class Entry<K,V> implements Map.Entry<K,V> {
K key;
V value;
Entry<K,V> left;
Entry<K,V> right;
Entry<K,V> parent;
boolean color = BLACK;
}
TreeMap是以红黑树来做存贮结构的，因为TreeMap是有序的，所以它存贮的对象都是必须实现Comparable或者Comparator接口的，以便于排序，它有4个构造方法：
//默认的构造方法
public TreeMap() {
comparator = null;
}
//接受外部的比较器
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
//接受一个Map实现类
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;
putAll(m);
}
//接受一个SortedMap实现类
public TreeMap(SortedMap<K, ? extends V> m) {
comparator = m.comparator();
try {
buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
}
默认是不用外部的比较器的，因为传进来的的对象是实现了Comparable或者Comparator接口。它的插入方法：
public V put(K key, V value)
{
// 先以 t 保存链表的 root 节点
Entry<K,V> t = root;
// 如果 t==null，表明是一个空链表，即该 TreeMap 里没有任何 Entry
if (t == null)
{
// 将新的 key-value 创建一个 Entry，并将该 Entry 作为 root
root = new Entry<K,V>(key, value, null);
// 设置该 Map 集合的 size 为 1，代表包含一个 Entry
size = 1;
// 记录修改次数为 1
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
Comparator<? super K> cpr = comparator;
// 如果比较器 cpr 不为 null，即表明采用定制排序
if (cpr != null)
{
do {
// 使用 parent 上次循环后的 t 所引用的 Entry
parent = t;
// 拿新插入 key 和 t 的 key 进行比较
cmp = cpr.compare(key, t.key);
// 如果新插入的 key 小于 t 的 key，t 等于 t 的左边节点
if (cmp < 0)
t = t.left;
// 如果新插入的 key 大于 t 的 key，t 等于 t 的右边节点
else if (cmp > 0)
t = t.right;
// 如果两个 key 相等，新的 value 覆盖原有的 value，
// 并返回原有的 value
else
return t.setValue(value);
} while (t != null);
}
else
{
if (key == null)
throw new NullPointerException();
Comparable<? super K> k = (Comparable<? super K>) key;
do {
// 使用 parent 上次循环后的 t 所引用的 Entry
parent = t;
// 拿新插入 key 和 t 的 key 进行比较
cmp = k.compareTo(t.key);
// 如果新插入的 key 小于 t 的 key，t 等于 t 的左边节点
if (cmp < 0)
t = t.left;
// 如果新插入的 key 大于 t 的 key，t 等于 t 的右边节点
else if (cmp > 0)
t = t.right;
// 如果两个 key 相等，新的 value 覆盖原有的 value，
// 并返回原有的 value
else
return t.setValue(value);
} while (t != null);
}
// 将新插入的节点作为 parent 节点的子节点
Entry<K,V> e = new Entry<K,V>(key, value, parent);
// 如果新插入 key 小于 parent 的 key，则 e 作为 parent 的左子节点
if (cmp < 0)
parent.left = e;
// 如果新插入 key 小于 parent 的 key，则 e 作为 parent 的右子节点
else
parent.right = e;
// 修复红黑树
fixAfterInsertion(e); // ①
size++;
modCount++;
return null;
}
LinkedHashMap
LinkedHashMap继承自HashMap类，它为了实现键值对的线性排列，即按照put进的顺序排列，以及兼顾O(1)性能，它依旧使用HashMap的Put方法，但是在其内部创立了一个链表，也是用来存贮键值对，并重写了newNode与newTreeNode方法：
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
LinkedHashMap.Entry<K,V> p =
new LinkedHashMap.Entry<K,V>(hash, key, value, e);
linkNodeLast(p);
return p;
}
TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
linkNodeLast(p);
return p;
}
LinkedHashMap每次调用这两个方法存贮新的键值对时，不仅将它的引用放进hashMap的桶中，同时将引用加入到LinkedHashMap的链表尾部。也就是说LinkedHashMap维护了两个数据结构，基于哈希值来进行存贮、查找的哈希桶，而其内部的链表则记录了键值对的put进桶的顺序，也就实现了线性化，这也是典型的空间换时间的方案。
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;
tail = p;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
}
其内部的accessOrder成员变量决定了新的节点插入链表尾部还是头部。
Hashtable
Hashtable相较于HashMap，它是HashMap的线程安全实现，它在临界资源上加了同步方法，同时又有点区别，主要是对于如下几点：
- 索引值的取法，Hashtable的索引值取法如下：
int index = (hash & 0x7FFFFFFF) % tab.length;
- 对于null的处理，HashMap是接受的，因为它将null作为一个对象，而Hashtable是不接受的，它会抛出异常：
if (value == null) {
throw new NullPointerException();
}
但是在Collections类中存在一个静态方法：synchronizedMap()，该方法创建了一个线程安全的Map对象，并把它作为一个封装的对象来返回，所以通过Collections类的synchronizedMap方法是可以同步访问潜在的HashMap，两者看个人的选择。