HashTable本身和hashMap差距不大，看了几个hashTable的内部方法实现，发现内部方法没有上锁，但是用public修饰的方法全部用synchronize加上了方法锁，这样是极其消耗性能的，好，我们来看几个内部方法的实现。
rehash()
protected void rehash() {
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// 将容量扩大为原来的两倍+1
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;
//这个地方有点意思，跟hashMap和ConcurrentHashmap的实现不一样
//前两者是使用hash值与旧数组长度进行与操作，然后分成两条链，直接放到相应位置
//而hashTable是从前面插入，也就是每插入一个节点，就将这个节点的next指向原有的首节点
//然后插入节点充当当前位置的首节点
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是通过取余来获取位置的，这个效率肯定不如hashmap，还有一个地方是hash和0x7fffffff进行了与操作，这个三个集合都有点不同，hashmap是先将hash值无符号右移16位然后再跟自身进行异或操作，这个是为了减少hash冲突，但是在ConcurrentHashmap中，它的hash值计算在这个基础上还跟0x7fffffff进行了与操作，而hashtable没有高16和低16位的异或操作，直接跟0x7fffffff进行与操作。
总结一下：
1、hashmap跟hashtable和ConcurrentHashmap的区别在于，后两者都是线程安全的集合，然后他们都跟0x7fffffff进行了与操作
2、hashTable的位置计算直接通过取余的方式，在位置选择上的性能上会低于hashmap和concurrentHashmap
3、ConcurrentHashmap中有个数据迁移的地方比较高明，在分成两条链进行插入的时候，它要对原有的链进行遍历，在遍历的过程中发现可以重用的节点，然后不用再二次创建这些节点，在使用中可能会大大提高性能够，因为这个类是处理高并发的集合。
addEntry
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++;
}
这个方法也比较简单，跟前面的rehash一样，插入新节点是从链表头插入的
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;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
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;
}
这个方法之所以拿出来讲，我们看第一条判断语句，value==null的判断，也就是说hashtable不支持value为空，但是支持key为空，hashmap既支持key也支持value为空，而ConcurrentHashMap是都不支持二者为空的情况，这个也是三个集合类的区别之一。
为什么要这样规定key或者value不能为空呢？（网上感觉比较合理的解释如下）
ConcurrentHashmap和Hashtable都是支持并发的，这样会有一个问题，当你通过get(k)获取对应的value时，如果获取到的是null时，你无法判断，它是put（k,v）的时候value为null，还是这个key从来没有做过映射。HashMap是非并发的，可以通过contains(key)来做这个判断。而支持并发的Map在调用m.contains（key）和m.get(key),m可能已经不同了。
clone
//Creates a shallow copy of this hashtable. All the structure of the
// hashtable itself is copied, but the keys and values are not cloned.
//This is a relatively expensive operation
public synchronized Object clone() {
try {
Hashtable<?,?> t = (Hashtable<?,?>)super.clone();
t.table = new Entry<?,?>[table.length];
for (int i = table.length ; i-- > 0 ; ) {
t.table[i] = (table[i] != null)
? (Entry<?,?>) table[i].clone() : null;
}
t.keySet = null;
t.entrySet = null;
t.values = null;
t.modCount = 0;
return t;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
看到方法上的注释可以知道这个类跟hashmap一样都是浅拷贝的，key和value值不拷贝，而相比于此，ConcurrentHashMap是没有提供拷贝方法的，也就是不能进行拷贝。
