记录了HashMap也来看看Hashtable吧，最近打算换份实习，所以想看看书回顾一下，不然就快记不得了.....囧啊囧啊，记性太差怎么破？？？
Hashtable里面的一些变量：
Entry<?,?>[] table : HashTable采用"拉链法"实现哈希表,每一个Entry代表了一个键值对(key-value)。
transient int count:hashtable里面键值对的个数;
private int threshold：hashtable的阀值（threshols = capacity * loadFactor);
float loadFactor:加载因子;
transient int modCount ：hashtable被修改的次数，用来实现fast-fail机制。fast-fail机制就是在并发集合中，其进行迭代操作时，若有其他线程对其进行结构性的修改，这时迭代器会立马感知到，并且立即抛出 ConcurrentModificationException异常。
Hashtable的定义如下：
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable {
...
}
可以看出Hashtable实现了Map接口，同时继承了Dictionary类。Map接口是将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。Dictionary 类是任何可将键映射到相应值的类（如 Hashtable）的抽象父类。每个键和每个值都是一个对象。在任何一个 Dictionary 对象中，每个键至多与一个值相关联。给定一个 Dictionary 和一个键，就可以查找所关联的元素。任何非 null 对象都可以用作键或值。
看看Hashtable常用的构造函数的实现：
默认的构造函数：容量为11，加载因子为0.75
public Hashtable() {
this(11, 0.75f);
}
用指定的初始容量和默认的加载因子构造：
public Hashtable(int initialCapacity) {
this(initialCapacity, 0.75f);
}
用指定的初始容量和指定的加载因子构造：
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数组
table = new Entry<?,?>[initialCapacity];
//计算table的阀值
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}
再来看看Put方法和get方法：
首先是put方法，put方法的整个处理流程是：计算key的hash值，根据hash值获得key在table数组中的索引位置，然后迭代该key处的Entry链表（我们暂且理解为链表），若该链表中存在一个这个的key对象，那么就直接替换其value值即可，否则在将改key-value节点插入该index索引位置处。注意，hashtable是不允许null值的。
int index = (hash & 0x7FFFFFFF) % tab.length——>键的hash值可能为负数，通过一个“与”操作，先将hash值都转化正数，然后将得到的hash值与Hashtable的长度求余
//同步实现
public synchronized V put(K key, V value) {
// check value值是否为null
if (value == null) {
throw new NullPointerException();
} // Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
//计算key的hash值
int hash = key.hashCode();
//通过hash值来计算在table数组中的下表
int index = (hash & 0x7FFFFFFF) % tab.length;
@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;
}
}
//没有找到，则将该key加入
addEntry(hash, key, value, index);
return null;
}
private void addEntry(int hash, K key, V value, int index) {
//修改链表，modCount自增
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++;
}
get方法也是同步的，具体的实现如下：
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
//计算key的hash值
int hash = key.hashCode();
//通过hash值来计算在table数组中的下表
int index = (hash & 0x7FFFFFFF) % tab.length;
//遍历查找key，找到则返回key值所对应的的value
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return (V)e.value;
}
}
return null;
}