标签：java集合源码剖析
Hashtable简介
Hashtable同样是基于哈希表实现的，同样每个元素是一个key-value对，其内部也是通过单链表解决冲突问题，容量不足（超过了阀值）时，同样会自动增长。
Hashtable也是JDK1.0引入的类，是线程安全的，能用于多线程环境中。
Hashtable同样实现了Serializable接口，它支持序列化，实现了Cloneable接口，能被克隆。
HashTable源码剖析
Hashtable的源码的很多实现都与HashMap差不多，源码如下（加入了比较详细的注释）：
-
package java.util;
-
import java.io.*;
-
-
public class Hashtable<K,V>
-
extends Dictionary<K,V>
-
implements Map<K,V>, Cloneable, java.io.Serializable {
-
-
-
-
private transient Entry[] table;
-
-
-
private transient int count;
-
-
-
private int threshold;
-
-
-
private float loadFactor;
-
-
-
private transient int modCount = 0;
-
-
-
private static final long serialVersionUID = 1421746759512286392L;
-
-
-
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)(initialCapacity * loadFactor);
-
}
-
-
-
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);
-
}
-
-
public synchronized int size() {
-
return count;
-
}
-
-
public synchronized boolean isEmpty() {
-
return count == 0;
-
}
-
-
-
public synchronized Enumeration<K> keys() {
-
return this.<K>getEnumeration(KEYS);
-
}
-
-
-
public synchronized Enumeration<V> elements() {
-
return this.<V>getEnumeration(VALUES);
-
}
-
-
-
public synchronized boolean contains(Object value) {
-
-
-
if (value == null) {
-
throw new NullPointerException();
-
}
-
-
-
-
Entry tab[] = table;
-
for (int i = tab.length ; i-- > 0 ;) {
-
for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) {
-
if (e.value.equals(value)) {
-
return true;
-
}
-
}
-
}
-
return false;
-
}
-
-
public boolean containsValue(Object value) {
-
return contains(value);
-
}
-
-
-
public synchronized boolean containsKey(Object key) {
-
Entry tab[] = table;
-
-
int hash = key.hashCode();
-
-
int index = (hash & 0x7FFFFFFF) % tab.length;
-
-
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
-
if ((e.hash == hash) && e.key.equals(key)) {
-
return true;
-
}
-
}
-
return false;
-
}
-
-
-
public synchronized V get(Object key) {
-
Entry tab[] = table;
-
int hash = key.hashCode();
-
-
int index = (hash & 0x7FFFFFFF) % tab.length;
-
-
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
-
if ((e.hash == hash) && e.key.equals(key)) {
-
return e.value;
-
}
-
}
-
return null;
-
}
-
-
-
protected void rehash() {
-
int oldCapacity = table.length;
-
Entry[] oldMap = table;
-
-
-
int newCapacity = oldCapacity * 2 + 1;
-
Entry[] newMap = new Entry[newCapacity];
-
-
modCount++;
-
threshold = (int)(newCapacity * loadFactor);
-
table = newMap;
-
-
-
for (int i = oldCapacity ; i-- > 0 ;) {
-
for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
-
Entry<K,V> e = old;
-
old = old.next;
-
-
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
-
e.next = newMap[index];
-
newMap[index] = e;
-
}
-
}
-
}
-
-
-
public synchronized V put(K key, V value) {
-
-
if (value == null) {
-
throw new NullPointerException();
-
}
-
-
-
-
Entry tab[] = table;
-
int hash = key.hashCode();
-
int index = (hash & 0x7FFFFFFF) % tab.length;
-
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
-
if ((e.hash == hash) && e.key.equals(key)) {
-
V old = e.value;
-
e.value = value;
-
return old;
-
}
-
}
-
-
-
-
modCount++;
-
-
-
if (count >= threshold) {
-
rehash();
-
-
tab = table;
-
index = (hash & 0x7FFFFFFF) % tab.length;
-
}
-
-
-
Entry<K,V> e = tab[index];
-
tab[index] = new Entry<K,V>(hash, key, value, e);
-
count++;
-
return null;
-
}
-
-
-
public synchronized V remove(Object key) {
-
Entry tab[] = table;
-
int hash = key.hashCode();
-
int index = (hash & 0x7FFFFFFF) % tab.length;
-
-
-
-
for (Entry<K,V> e = tab[index], prev = null ; e != null ; prev = e, e = e.next) {
-
if ((e.hash == hash) && e.key.equals(key)) {
-
modCount++;
-
if (prev != null) {
-
prev.next = e.next;
-
} else {
-
tab[index] = e.next;
-
}
-
count--;
-
V oldValue = e.value;
-
e.value = null;
-
return oldValue;
-
}
-
}
-
return null;
-
}
-
-
-
public synchronized void putAll(Map<? extends K, ? extends V> t) {
-
for (Map.Entry<? extends K, ? extends V> e : t.entrySet())
-
put(e.getKey(), e.getValue());
-
}
-
-
-
-
public synchronized void clear() {
-
Entry tab[] = table;
-
modCount++;
-
for (int index = tab.length; --index >= 0; )
-
tab[index] = null;
-
count = 0;
-
}
-
-
-
public synchronized Object clone() {
-
try {
-
Hashtable<K,V> t = (Hashtable<K,V>) super.clone();
-
t.table = new Entry[table.length];
-
for (int i = table.length ; i-- > 0 ; ) {
-
t.table[i] = (table[i] != null)
-
? (Entry<K,V>) table[i].clone() : null;
-
}
-
t.keySet = null;
-
t.entrySet = null;
-
t.values = null;
-
t.modCount = 0;
-
return t;
-
} catch (CloneNotSupportedException e) {
-
throw new InternalError();
-
}
-
}
-
-
public synchronized String toString() {
-
int max = size() - 1;
-
if (max == -1)
-
return "{}";
-
-
StringBuilder sb = new StringBuilder();
-
Iterator<Map.Entry<K,V>> it = entrySet().iterator();
-
-
sb.append(‘{‘);
-
for (int i = 0; ; i++) {
-
Map.Entry<K,V> e = it.next();
-
K key = e.getKey();
-
V value = e.getValue();
-
sb.append(key == this ? "(this Map)" : key.toString());
-
sb.append(‘=‘);
-
sb.append(value == this ? "(this Map)" : value.toString());
-
-
if (i == max)
-
return sb.append(‘}‘).toString();
-
sb.append(", ");
-
}
-
}
-
-
-
-
-
private <T> Enumeration<T> getEnumeration(int type) {
-
if (count == 0) {
-
return (Enumeration<T>)emptyEnumerator;
-
} else {
-
return new Enumerator<T>(type, false);
-
}
-
}
-
-
-
-
-
private <T> Iterator<T> getIterator(int type) {
-
if (count == 0) {
-
return (Iterator<T>) emptyIterator;
-
} else {
-
return new Enumerator<T>(type, true);
-
}
-
}
-
-
-
private transient volatile Set<K> keySet = null;
-
-
private transient volatile Set<Map.Entry<K,V>> entrySet = null;
-
-
private transient volatile Collection<V> values = null;
-
-
-
-
public Set<K> keySet() {
-
if (keySet == null)
-
keySet = Collections.synchronizedSet(new KeySet(), this);
-
return keySet;
-
}
-
-
-
-
private class KeySet extends AbstractSet<K> {
-
public Iterator<K> iterator() {
-
return getIterator(KEYS);
-
}
-
public int size() {
-
return count;
-
}
-
public boolean contains(Object o) {
-
return containsKey(o);
-
}
-
public boolean remove(Object o) {
-
return Hashtable.this.remove(o) != null;
-
}
-
public void clear() {
-
Hashtable.this.clear();
-
}
-
}
-
-
-
-
public Set<Map.Entry<K,V>> entrySet() {
-
if (entrySet==null)
-
entrySet = Collections.synchronizedSet(new EntrySet(), this);
-
return entrySet;
-
}
-
-
-
-
private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
-
public Iterator<Map.Entry<K,V>> iterator() {
-
return getIterator(ENTRIES);
-
}
-
-
public boolean add(Map.Entry<K,V> o) {
-
return super.add(o);
-
}
-
-
-
-
-
public boolean contains(Object o) {
-
if (!(o instanceof Map.Entry))
-
return false;
-
Map.Entry entry = (Map.Entry)o;
-
Object key = entry.getKey();
-
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.equals(entry))
-
return true;
-
return false;
-
}
-
-
-
-
-
public boolean remove(Object o) {
-
if (!(o instanceof Map.Entry))
-
return false;
-
Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
-
K key = entry.getKey();
-
Entry[] tab = table;
-
int hash = key.hashCode();
-
int index = (hash & 0x7FFFFFFF) % tab.length;
-
-
for (Entry<K,V> e = tab[index], prev = null; e != null;
-
prev = e, e = e.next) {
-
if (e.hash==hash && e.equals(entry)) {
-
modCount++;
-
if (prev != null)
-
prev.next = e.next;
-
else
-
tab[index] = e.next;
-
-
count--;
-
e.value = null;
-
return true;
-
}
-
}
-
return false;
-
}
-
-
public int size() {
-
return count;
-
}
-
-
public void clear() {
-
Hashtable.this.clear();
-
}
-
}
-
-
-
-
public Collection<V> values() {
-
if (values==null)
-
values = Collections.synchronizedCollection(new ValueCollection(),
-
this);
-
return values;
-
}
-
-
-
-
private class ValueCollection extends AbstractCollection<V> {
-
public Iterator<V> iterator() {
-
return getIterator(VALUES);
-
}
-
public int size() {
-
return count;
-
}
-
public boolean contains(Object o) {
-
return containsValue(o);
-
}
-
public void clear() {
-
Hashtable.this.clear();
-
}
-
}
-
-
-
-
public synchronized boolean equals(Object o) {
-
if (o == this)
-
return true;
-
-
if (!(o instanceof Map))
-
return false;
-
Map<K,V> t = (Map<K,V>) o;
-
if (t.size() != size())
-
return false;
-
-
try {
-
-
-
-
Iterator<Map.Entry<K,V>> i = entrySet().iterator();
-
while (i.hasNext()) {
-
Map.Entry<K,V> e = i.next();
-
K key = e.getKey();
-
V value = e.getValue();
-
if (value == null) {
-
if (!(t.get(key)==null && t.containsKey(key)))
-
return false;
-
} else {
-
if (!value.equals(t.get(key)))
-
return false;
-
}
-
}
-
} catch (ClassCastException unused) {
-
return false;
-
} catch (NullPointerException unused) {
-
return false;
-
}
-
-
return true;
-
}
-
-
-
-
-
public synchronized int hashCode() {
-
int h = 0;
-
if (count == 0 || loadFactor < 0)
-
return h;
-
-
loadFactor = -loadFactor;
-
Entry[] tab = table;
-
for (int i = 0; i < tab.length; i++)
-
for (Entry e = tab[i]; e != null; e = e.next)
-
h += e.key.hashCode() ^ e.value.hashCode();
-
loadFactor = -loadFactor;
-
-
return h;
-
}
-
-
-
-
private synchronized void writeObject(java.io.ObjectOutputStream s)
-
throws IOException
-
{
-
-
s.defaultWriteObject();
-
-
-
s.writeInt(table.length);
-
s.writeInt(count);
-
for (int index = table.length-1; index >= 0; index--) {
-
Entry entry = table[index];
-
-
while (entry != null) {
-
s.writeObject(entry.key);
-
s.writeObject(entry.value);
-
entry = entry.next;
-
}
-
}
-
}
-
-
-
-
private void readObject(java.io.ObjectInputStream s)
-
throws IOException, ClassNotFoundException
-
{
-
-
s.defaultReadObject();
-
-
-
int origlength = s.readInt();
-
int elements = s.readInt();
-
-
-
-
-
-
int length = (int)(elements * loadFactor) + (elements / 20) + 3;
-
if (length > elements && (length & 1) == 0)
-
length--;
-
if (origlength > 0 && length > origlength)
-
length = origlength;
-
-
Entry[] table = new Entry[length];
-
count = 0;
-
-
-
for (; elements > 0; elements--) {
-
K key = (K)s.readObject();
-
V value = (V)s.readObject();
-
-
reconstitutionPut(table, key, value);
-
}
-
this.table = table;
-
}
-
-
private void reconstitutionPut(Entry[] tab, K key, V value)
-
throws StreamCorruptedException
-
{
-
if (value == null) {
-
throw new java.io.StreamCorruptedException();
-
}
-
-
-
int hash = key.hashCode();
-
int index = (hash & 0x7FFFFFFF) % tab.length;
-
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
-
if ((e.hash == hash) && e.key.equals(key)) {
-
throw new java.io.StreamCorruptedException();
-
}
-
}
-
-
Entry<K,V> e = tab[index];
-
tab[index] = new Entry<K,V>(hash, key, value, e);
-
count++;
-
}
-
-
-
-
private static class Entry<K,V> implements Map.Entry<K,V> {
-
-
int hash;
-
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;
-
}
-
-
protected Object clone() {
-
return new Entry<K,V>(hash, key, value,
-
(next==null ? null : (Entry<K,V>) next.clone()));
-
}
-
-
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 ^ (value==null ? 0 : value.hashCode());
-
}
-
-
public String toString() {
-
return key.toString()+"="+value.toString();
-
}
-
}
-
-
private static final int KEYS = 0;
-
private static final int VALUES = 1;
-
private static final int ENTRIES = 2;
-
-
-
private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
-
-
Entry[] table = Hashtable.this.table;
-
-
int index = table.length;
-
Entry<K,V> entry = null;
-
Entry<K,V> lastReturned = null;
-
int type;
-
-
-
-
boolean iterator;
-
-
-
protected int expectedModCount = modCount;
-
-
Enumerator(int type, boolean iterator) {
-
this.type = type;
-
this.iterator = iterator;
-
}
-
-
-
public boolean hasMoreElements() {
-
Entry<K,V> e = entry;
-
int i = index;
-
Entry[] t = table;
-
-
while (e == null && i > 0) {
-
e = t[--i];
-
}
-
entry = e;
-
index = i;
-
return e != null;
-
}
-
-
-
-
-
-
public T nextElement() {
-
Entry<K,V> et = entry;
-
int i = index;
-
Entry[] t = table;
-
-
while (et == null && i > 0) {
-
et = t[--i];
-
}
-
entry = et;
-
index = i;
-
if (et != null) {
-
Entry<K,V> e = lastReturned = entry;
-
entry = e.next;
-
return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);
-
}
-
throw new NoSuchElementException("Hashtable Enumerator");
-
}
-
-
-
-
public boolean hasNext() {
-
return hasMoreElements();
-
}
-
-
-
-
public T next() {
-
if (modCount != expectedModCount)
-
throw new ConcurrentModificationException();
-
return nextElement();
-
}
-
-
-
-
-
public void remove() {
-
if (!iterator)
-
throw new UnsupportedOperationException();
-
if (lastReturned == null)
-
throw new IllegalStateException("Hashtable Enumerator");
-
if (modCount != expectedModCount)
-
throw new ConcurrentModificationException();
-
-
synchronized(Hashtable.this) {
-
Entry[] tab = Hashtable.this.table;
-
int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length;
-
-
for (Entry<K,V> e = tab[index], prev = null; e != null;
-
prev = e, e = e.next) {
-
if (e == lastReturned) {
-
modCount++;
-
expectedModCount++;
-
if (prev == null)
-
tab[index] = e.next;
-
else
-
prev.next = e.next;
-
count--;
-
lastReturned = null;
-
return;
-
}
-
}
-
throw new ConcurrentModificationException();
-
}
-
}
-
}
-
-
-
private static Enumeration emptyEnumerator = new EmptyEnumerator();
-
private static Iterator emptyIterator = new EmptyIterator();
-
-
-
-
private static class EmptyEnumerator implements Enumeration<Object> {
-
-
EmptyEnumerator() {
-
}
-
-
-
public boolean hasMoreElements() {
-
return false;
-
}
-
-
-
public Object nextElement() {
-
throw new NoSuchElementException("Hashtable Enumerator");
-
}
-
}
-
-
-
-
-
private static class EmptyIterator implements Iterator<Object> {
-
-
EmptyIterator() {
-
}
-
-
public boolean hasNext() {
-
return false;
-
}
-
-
public Object next() {
-
throw new NoSuchElementException("Hashtable Iterator");
-
}
-
-
public void remove() {
-
throw new IllegalStateException("Hashtable Iterator");
-
}
-
-
}
-
}
几点总结
针对Hashtable，我们同样给出几点比较重要的总结，但要结合与HashMap的比较来总结。
1、二者的存储结构和解决冲突的方法都是相同的。
2、HashTable在不指定容量的情况下的默认容量为11，而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。
3、Hashtable中key和value都不允许为null，而HashMap中key和value都允许为null（key只能有一个为null，而value则可以有多个为null）。但是如果在Hashtable中有类似put(null,null)的操作，编译同样可以通过，因为key和value都是Object类型，但运行时会抛出NullPointerException异常，这是JDK的规范规定的。我们来看下ContainsKey方法和ContainsValue的源码：
-
-
public synchronized boolean contains(Object value) {
-
-
-
if (value == null) {
-
throw new NullPointerException();
-
}
-
-
-
-
Entry tab[] = table;
-
for (int i = tab.length ; i-- > 0 ;) {
-
for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) {
-
if (e.value.equals(value)) {
-
return true;
-
}
-
}
-
}
-
return false;
-
}
-
-
public boolean containsValue(Object value) {
-
return contains(value);
-
}
-
-
-
public synchronized boolean containsKey(Object key) {
-
Entry tab[] = table;
-
/计算hash值，直接用key的hashCode代替
-
int hash = key.hashCode();
-
-
int index = (hash & 0x7FFFFFFF) % tab.length;
-
-
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
-
if ((e.hash == hash) && e.key.equals(key)) {
-
return true;
-
}
-
}
-
return false;
-
}
很明显，如果value为null，会直接抛出NullPointerException异常，但源码中并没有对key是否为null判断，有点小不解！不过NullPointerException属于RuntimeException异常，是可以由JVM自动抛出的，也许对key的值在JVM中有所限制吧。
4、Hashtable扩容时，将容量变为原来的2倍加1，而HashMap扩容时，将容量变为原来的2倍。
5、Hashtable计算hash值，直接用key的hashCode()，而HashMap重新计算了key的hash值，Hashtable在求hash值对应的位置索引时，用取模运算，而HashMap在求位置索引时，则用与运算，且这里一般先用hash&0x7FFFFFFF后，再对length取模，&0x7FFFFFFF的目的是为了将负的hash值转化为正值，因为hash值有可能为负数，而&0x7FFFFFFF后，只有符号外改变，而后面的位都不变。
【Java集合源码剖析】Hashtable源码剖析
标签：java集合源码剖析
原文地址：http://blog.csdn.net/goluck98/article/details/44257833
