话不多说，直接上菜.............
Hashtable存储的内容是键值对(key-value)映射，其底层实现是一个Entry数组+链表；
Hashtable和HashMap一样也是散列表，存储元素也是键值对（JDK8 hashmap 加入了红黑树机制）；
HashMap允许key和value都为null，而Hashtable都不能为null，Hashtable中的映射不是有序的；
Hashtable和HashMap扩容的方法不一样，Hashtable中数组默认大小11，扩容方式是 old*2+1。HashMap中数组的默认大小是16，而且一定是2的指数，增加为原来的2倍。
Hashtable继承于Dictionary类（Dictionary类声明了操作键值对的接口方法），实现Map接口（定义键值对接口）； Hashtable大部分类用synchronized修饰，证明Hashtable是线程安全的。
HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了 HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出 ConcurrentModificationException异常。table数组索引计算方式不同：hashmap index = (n - 1) & hash 其hash算法：(key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);int hash = key.hashCode(); hashtable int index = (hash & 0x7FFFFFFF) % tab.length;
HashMap中：initialCapacity=16，loadFactory=0.75
HashTable中：initialCapacity=11，loadFactory=0.75Java8，HashMap中，当出现冲突时，
- 如果冲突数量小于8，则是以链表方式解决冲突。
- 而当冲突大于等于8时，就会将冲突的Entry转换为红黑树进行存储。
- 而又当数量小于6时，则又转化为链表存储。
而在HashTable中， 则都是以链表方式存储。
其中原委，下面分析其中几个重要方法的分析，其中主要方法被synchronized修饰，故线程安全:
首先是类成员变量：
// 键值对/Entry数组，每个Entry本质上是一个单向链表的表头
private transient Entry<?, ?>[] table;
//当前表中的Entry数量，如果超过了阈值，就会扩容，即调用rehash方法
private transient int count;
//rehash阈值
private int threshold;
// 负载因子
private float loadFactor;
/**
* 用来实现"fail-fast"机制的（也就是快速失败）。所谓快速失败就是在并发集合中，其进行
* 迭代操作时，若有其他线程对其进行结构性的修改，这时迭代器会立马感知到，并且立即抛出
* ConcurrentModificationException异常，而不是等到迭代完成之后才告诉你（你已经出错了）。
*HashTable大部分类被synchronized修饰，是线程安全的，没有fail-fast机制
*/
private transient int modCount = 0; //下面是其构造方法，默认构造方法可从中看出容量默认大小为initialCapacity=11，负载因子loadFactor默认是0.75
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);
}
//负载因子loadFactor默认是0.75
public Hashtable(int initialCapacity) {
this(initialCapacity, 0.75f);
}
//容量默认大小为initialCapacity=11，负载因子loadFactor默认是0.75
public Hashtable() {
this(11, 0.75f);
}contains方法：判断是否含有该value的键值对，在Hashtable中hashCode相同的Entry用链表组织，看看Entry就是一个链表结构，key，value，hash值以及指向下一个节点的Entry
private static class Entry<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Entry<K,V> next;
protected Entry(int hash, K key, V value, Entry<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
@SuppressWarnings("unchecked")
protected Object clone() {
return new Entry<>(hash, key, value,
(next==null ? null : (Entry<K,V>) next.clone()));
}
// Map.Entry Ops
public K getKey() {
return key;
}
public V getValue() {
return value;
}
public V setValue(V value) {
if (value == null)
throw new NullPointerException();
V oldValue = this.value;
this.value = value;
return oldValue;
}
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
(value==null ? e.getValue()==null : value.equals(e.getValue()));
}
public int hashCode() {
return hash ^ Objects.hashCode(value);
}
public String toString() {
return key.toString()+"="+value.toString();
}
}
hashCode不同的存储在Entry数组table中
public synchronized boolean contains(Object value) {
//hashtable不能为空，否则抛空异常
if (value == null) {
throw new NullPointerException();
}
Entry<?,?> tab[] = table;
//从尾部向前查找
for (int i = tab.length ; i-- > 0 ;) {
//遍历每个不为空的链表结构，如果找到就返回
for (Entry<?,?> e = tab[i] ; e != null ; e = e.next) {
if (e.value.equals(value)) {
return true;
}
}
}
return false;
}put方法被synchronized修饰，将key和value放到map中，明显表明key和value不能为null,不然将抛出null异常
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();
//利用hashcode去除table.length，然后取长度。
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
//判断tab[index]是否已经有值
Entry<K,V> entry = (Entry<K,V>)tab[index];
//如果有值，则遍历
for(; entry != null ; entry = entry.next) {
//如果key重复，那么新的value覆盖旧值
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;
}remove方法也被synchronized修饰，不是fast-fail机制
public synchronized V remove(Object key) {
Entry<?,?> tab[] = table;
//获取key的hashcode
int hash = key.hashCode();
//计算索引
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
//获得索引出的链表
Entry<K,V> e = (Entry<K,V>)tab[index];
//遍历链表，找到需要的进行删除，modCount加一
for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
modCount++;
if (prev != null) {
//那么pre结点的next指针指向e的next,等价于e被删除
prev.next = e.next;
} else {
//否则，说明需要删除的为起始结点
tab[index] = e.next;
}
count--;
V oldValue = e.value;
e.value = null;
return oldValue;
}
}
return null;
}get方法依然被synchronized修饰
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return (V)e.value;
}
}
return null;
}rehash方法：当Hashtable中键值对总数超过阈值（容量*装载因子）后，内部自动调用rehash()增加容量，重新计算每个键值对的hashCode，int newCapacity = (oldCapacity << 1) + 1计算新容量 = 2 * 旧容量 + 1；并且根据新容量更新阈值。
protected void rehash() {
//旧的容量和Entry数组
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
//新的容量，扩容机制：原大小 * 2 + 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;
}
//新的Enrty数组，带着新的容量
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
//散列表内的元素发生变化，modCount指针加1
modCount++;
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
table = newMap;
//把旧的链表重新计算index放入到新的链表中
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;
}
}
}
参考：https://blog.csdn.net/qq_29864971/article/details/79326106
228
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
