Map--Hashtable
Map
Map集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。Java自带了各种Map类，主要分为以下三类：
1、通用Map，用于在应用程序中管理映射，通常放置在java.util包中：HashMap、Hashtable、Properties、LinkedHashMap、IdentityHashMap、TreeMap、WeakHashMap、ConcurrentHashMap
2、专用Map，通常我们不必亲自创建此类Map，而是通过某些其他类对其进行访问：java.util.jar.Attributes、javax.print.attribute.standard.PrinterStateReasons、java.security.Provider、java.awt.RenderingHints、javax.swing.UIDefaults
3、一个用于帮助我们实现自己的Map类的抽象类AbstractMap
Map的常用方法
| 1 | void clear( ) 从此映射中移除所有映射关系（可选操作）。 |
|---|---|
| 2 | boolean containsKey(Object k) 如果此映射包含指定键的映射关系，则返回 true。 |
| 3 | boolean containsValue(Object v) 如果此映射将一个或多个键映射到指定值，则返回 true。 |
| 4 | Set entrySet( ) 返回此映射中包含的映射关系的 Set 视图。 |
| 5 | boolean equals(Object obj) 比较指定的对象与此映射是否相等。 |
| 6 | Object get(Object k) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 |
| 7 | int hashCode( ) 返回此映射的哈希码值。 |
| 8 | boolean isEmpty( ) 如果此映射未包含键-值映射关系，则返回 true。 |
| 9 | Set keySet( ) 返回此映射中包含的键的Set视图。 |
| 10 | Object put(Object k, Object v) 将指定的值与此映射中的指定键关联（可选操作）。 |
| 11 | void putAll(Map m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。 |
| 12 | Object remove(Object k) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 |
| 13 | int size( ) 返回此映射中的键-值映射关系数。 |
| 14 | Collection values( ) 返回此映射中包含的值的 Collection 视图。 |
Hashtable
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable
实现了Map接口，继承了Dictionary类，Dictionary类是任何可以将键映射到相应值的类的父类。每个键和每个值都是一个对象。在任何一个Dictionary对象中，每个键至多与一个值相关联。
重要参数
HashTable采用"拉链法"实现哈希表，它定义了几个重要的参数：table、count、threshold、loadFactor、modCount。
// 为一个Entry[]数组类型，Entry代表了“拉链”的节点，每一个Entry代表了一个键值对，哈希表的"key-value键值对"都是存储在Entry数组中的。
private transient Entry<?,?>[] table;
// HashTable的大小，这个大小并不是HashTable的容器大小，而是它所包含Entry键值对的数量。
private transient int count;
// Hashtable的阈值，用于判断是否需要调整Hashtable的容量。threshold的值="容量*加载因子"。
private int threshold;
// 加载因子
private float loadFactor;
// 用来实现“fail-fast”机制的（也就是快速失败）。所谓快速失败就是在并发集合中，其进行迭代操作时，若有其他线程对其进行结构性的修改，这时迭代器会立马感知到，并且立即抛出ConcurrentModificationException异常，而不是等到迭代完成之后才告诉你
private transient int modCount = 0;
构造方法
public Hashtable(int initialCapacity) {
this(initialCapacity, 0.75f);
}
public Hashtable() {
this(11, 0.75f);
}
public Hashtable(Map<? extends K, ? extends V> t) {
this(Math.max(2*t.size(), 11), 0.75f);
putAll(t);
}
默认构造函数，容量为11，加载因子为0.75，所以初始化时，HashTable的初始容量为11。也可以在初始化，只指定初始容量，此时默认的加载因子依旧是0.75。
也可以直接传入一个Map集合，此时的容量会设置为11与传入Map集合大小的两倍之间的最大值。
这三个构造方法调用的都是下面这个构造方法：
public Hashtable(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal Load: "+loadFactor);
if (initialCapacity==0)
initialCapacity = 1;
this.loadFactor = loadFactor;
table = new Entry<?,?>[initialCapacity];
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}
Hashtable是线程安全的，因为其内部的公有方法基本上都被synchronized修饰了，所以是线程安全的。
存数据流程
put方法是往Hashtable中存入数据的方式，下面看一下put方法的源码：
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length; //确认该key的索引位置
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
//迭代，寻找该key，替换
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
addEntry(hash, key, value, index);
return null;
}
1、首先要确保存入的键值对的value不为null，如果为null，直接抛出异常
2、然后就是要确保集合中的key是不重复的，处理过程是：
（1）计算key的hash值，确认在table[]中的索引位置
（2）迭代index索引位置，如果该位置处的链表中存在一个一样的key，则替换其value，返回旧值。
3、确认要添加的key不是重复的以后，就将这个新的键值对添加到Entry数组中，即执行addEntry方法，顺带传入键值对以及哈希值，还有这个键值对在Entry数组中的索引值。
private void addEntry(int hash, K key, V value, int index) {
modCount++;
Entry<?,?> tab[] = table;
//如果容器中的元素数量已经达到阀值，则进行扩容操作
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
rehash();
tab = table;
hash = key.hashCode();
index = (hash & 0x7FFFFFFF) % tab.length;
}
// Creates the new entry.
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>) tab[index];
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
4、添加之前要确认容器中的元素数量是否达到阈值，如果大于等于阈值，则进行扩容，扩容的机制在下面有讲解。扩容之后，会重新为要添加的键值对计算哈希值和索引值。
5、依据对象的哈希值，确定键值对在数组中的位置，然后在这个位置上插入一个新的节点。
hash值确定键值对在Entry数组中的位置，index值确定键值对在这个位置的链表中位于链表的哪个具体位置。
总结一下
put方法的整个处理流程是：计算key的hash值，根据hash值获得key在table数组中的索引位置，然后迭代该key处的Entry链表（我们暂且理解为链表），若该链表中存在一个这个的key对象，那么就直接替换其value值即可，否则将该key-value节点插入该index索引位置处。
当程序试图将一个key-value对放入Hashtable中时，程序首先根据该对象的key的 hashCode() 返回值决定该 Entry 的存储位置：如果两个Entry的key的hashCode() 返回值相同，那它们的存储位置相同。如果这两个Entr的 key通过equals比较返回true，新添加 Entry的value将覆盖集合中原有Entry的value，但key不会覆盖。如果这两个 Entry的key通过equals比较返回false，新添加的Entry将与集合中原有Entry形成Entry链，而且新添加的Entry位于 Entry链的头部。
扩容机制
在put方法中，如果需要向table[]中添加Entry元素，会首先进行容量校验，如果容量已经达到了阀值，HashTable就会进行扩容处理rehash()：
protected void rehash() {
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// overflow-conscious code
int newCapacity = (oldCapacity << 1) + 1;
if (newCapacity - MAX_ARRAY_SIZE > 0) {
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
newCapacity = MAX_ARRAY_SIZE;
}
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
modCount++;
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
table = newMap;
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = (Entry<K,V>)newMap[index];
newMap[index] = e;
}
}
}
从源码可以看出HashTable的扩容操作是：新容量=旧容量 * 2 + 1。同时需要将原来HashTable中的元素一一复制到新的HashTable中，这个过程是比较消耗时间的，同时还需要重新计算hashSeed的，毕竟容量已经变了。
其中还需要注意的是，扩容之后，阈值发送了改变。
