public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.SerializableHashTable 是 Java 中哈希表的一种实现形式，它是 Dictionary 的子类，并且实现了 Map 接口。
注1：
哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
注2：
Dictionary 类是一个能将键（key）映射到相应的值（value）的抽象父类，其中键和值都是对象，但在任何一个 Dictionary 对象中，每个键至多与一个值形成映射关系。
注3：
Map 则是定义了具有键值对关系的对象能进行的行为的接口
了解了 HashTable 的相关概念之后，我们就该想想：HashTable 的具体实现原理是什么呢？我们不妨先简单看看 HashTable 的源码：
注4：
为了让大家别太头疼，我把注释部分去掉了，想要看注释的可以自己到文档里边看，在下面的讲解中有必要的地方我也会给大家指出
private transient Entry<?,?>[] table;
private transient int count;
private int threshold;
private float loadFactor;
private transient int modCount = 0;
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);
}
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);
}从 HashTable 最基本的构造方法和相关属性我们可以注意到：
那么我们不妨就从这两点入手，研究 HashTable 的内部结构。
我们不妨直接看 HashTable 的源码：
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();
}
}我不知道大家有没有似曾相识的感觉，反正我第一眼看到 Entry 类内的属性就反应过来了：Entry 其实就是一个链表。也就是说，HashTable 内部是结合数组和列表实现哈希表的，具体构造如图：
注5：
数组+链表实现哈希表采用的是链地址法解决冲突，具体内容可以参考我初学哈希表时的一篇博文：简单的哈希表实现（链地址法解决冲突）
从注释来看，initialCapacity 是 HashTable 的初始容量，而 loadFactor 是 HashTable 的装载因子。initialCapacity 的作用倒是好懂，就是表示新创建的 HashTable 的容量嘛。那个 loadFactor 是个什么鬼……别急，这就给你解释：
loadFactor 是 HashTable 用于衡量自身容量的值，例如 HashTable 的初始容量为20，装载因子为0.75，那么当 HashTable 中的键值对数量超过15（20*0.75）之后，HashTable 则会调用 rehash() 方法增大其容量，再将待添加的键值对加入 HashTable。
你觉得我在胡扯？不信看源码！
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++;
}在我们调用 addEntry() 方法添加新的键值对时，首先会比较当前键值对的数量与装载上限量，如果超过装载上限则会执行 rehash() 方法。
注6：
threshold 就是装载上限，计算公式为：
java threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
@SuppressWarnings("unchecked")
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;
}
}
}在 rehash() 方法中则会进行相应的重哈希和新建 Entry 数组的操作。那么 Entry 数组到底会变大多少呢？答案是增大为当前最大容量的两倍：
int newCapacity = (oldCapacity << 1) + 1;在 HashTable 中，键与值的对象都不能是 null
为了能够成功存储和检索到相应的值，用作键的对象必须实现 hashCode() 和 equals() 方法
HashTable 是线程安全的类，其中的方法都实现了 synchronized 关键字。正如我在 String、StringBuffer、StringBuilder的区别及使用 中提到，当你不需要考虑并发时，重复的加锁解锁会带来效率的问题，此外，HashTable 这种保证线程安全的方法也不好。所以在 StackOverflow 的讨论中大部分人也同意：HashTable 已经是过去的类了，并不提倡大家使用 HashTable。
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, SerializableHashMap 是 Java 中哈希表的一种实现形式，它是 AbstractMap 的子类，并且实现了 Map 接口。事实上 HashMap 与 HashTable 是很相似的，虽然 HashMap 继承于 AbstractMap 类，但是我们进入AbstractMap 类的代码：
public abstract class AbstractMap<K,V> implements Map<K,V>AbstractMap 类只是一个实现了 Map 接口的抽象类而已。可能有人就会问了，既然 AbstractMap 类已经实现了 Map 接口，为什么 HashMap 还要实现 Map 接口，这不是多此一举么？非也，这是因为目前尚未确定 HashMap 会不会发生改变，此时 AbstractMap 只是 HashMap 的实现细节，如果有一天决定取消 AbstractMap 与 HashMap 的父子关系，那就需要重新写 HashMap 的代码了，而这又是没有必要的，因为 HashMap 所依赖的抽象逻辑 Map 接口就可以提供。
同样的，我们截取 HashMap 最基本的组成：属性和构造方法来开始我们的分析的话会发现，HashMap 的实现原理和 HashTable 几乎一样，都是用 Entry 数组进行存储，链地址法解决哈希表中的冲突。并且使用了 initialCapacity 和 loadFactor。
虽说 HashMap 与 HashTable 非常相似，但 HashMap 在细节处还是有改变的：
HashMap 的键和值都允许是 null
HashMap 是线程不安全的，但这意味着在非并发情况下 HashMap 是比 HashTable 更好的选择（效率更高），即便是需要考虑并发的情况，我们只要通过 Collections 类的 synchronizedMap 方法就可以获得线程安全的 HashMap，抑或是通过 ConcurrentHashMap 来实现线程安全。
HashMap 不能保证随着时间的推移，元素的次序不会发生改变
HashMap 的迭代器(Iterator)是 fail-fast 迭代器，而 Hashtable 的 enumerator 迭代器不是 fail-fast 。所以当有其它线程改变了 HashMap 的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的 remove() 方法移除元素则不会抛出ConcurrentModificationExceptio n异常。但这并不是一个一定发生的行为，要看 JVM 。这条同样也是Enumeration和Iterator的区别。
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.SerializableHashSet 是 Java 中哈希表的一种实现形式，它是 AbstractSet 的子类，并且实现了 Set 接口。但值得注意的是，HashSet 一般用于进行高性能集运算，而实现 Set 接口使 HashSet 中不会出现重复元素。
static final long serialVersionUID = -5024744406713321676L;
private transient HashMap<E,Object> map;
private static final Object PRESENT = new Object();
public HashSet() {
map = new HashMap<>();
}
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}从源码可以看到，HashSet 的内部实现都依赖于 HashMap，也就是说，HashSet 其实就是为了进行几何运算对 HashMap 进行了封装，其他区别倒是不大。
HashSet 在计算成员的哈希值时，直接通过对象进行运算，而 HashMap 则是通过存储对象对应的键进行运算
深入源码剖析 HashSet、HashMap、HashTable
原文地址：http://blog.csdn.net/u012403246/article/details/45865897
