深刻Java集合学习系列：Hashtable的实现原理

时间 2019-12-07

标签深刻 java 集合学习系列 hashtable 实现原理栏目 Java 繁體版

原文原文链接

第1部分 Hashtable介绍

　　和HashMap同样，Hashtable也是一个散列表，它存储的内容是键值对(key-value)映射。Hashtable继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。Hashtable的函数都是同步的，这意味着它是线程安全的。它的key、value都不能够为null。此外，Hashtable中的映射不是有序的。Hashtable的实例有两个参数影响其性能：初始容量和加载因子。容量是哈希表桶的数量，初始容量就是哈希表建立时的容量。注意，哈希表的状态为 open：在发生“哈希冲突”的状况下，单个桶会存储多个条目，这些条目必须按顺序搜索。加载因子是对哈希表在其容量自动增长以前能够达到多满的一个尺度。初始容量和加载因子这两个参数只是对该实现的提示。关于什么时候以及是否调用rehash方法的具体细节则依赖于该实现。一般，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折衷。加载因子太高虽然减小了空间开销，但同时也增长了查找某个条目的时间。html

第2部分 Hashtable数据结构

java.lang.Object
   ↳     java.util.Dictionary<K, V>
         ↳     java.util.Hashtable<K, V>

public class Hashtable<K,V> extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable { }

　　Hashtable与Map关系以下图：java

从图中能够看出：数组

　　(01) Hashtable继承于Dictionary类，实现了Map接口。Map是"key-value键值对"接口，Dictionary是声明了操做"键值对"函数接口的抽象类。
　　(02) Hashtable是经过"拉链法"实现的哈希表。它包括几个重要的成员变量：table, count, threshold, loadFactor, modCount。
　　table是一个Entry[]数组类型，而Entry实际上就是一个单向链表。哈希表的"key-value键值对"都是存储在Entry数组中的。count是Hashtable的大小，它是Hashtable保存的键值对的数量。threshold是Hashtable的阈值，用于判断是否须要调整Hashtable的容量。threshold的值="容量*加载因子"。loadFactor就是加载因子。 modCount是用来实现fail-fast机制的安全

第3部分 Hashtable源码解析(基于JDK1.6.0_45)

package java.util; import java.io.*; public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable { // Hashtable保存key-value的数组。 // Hashtable是采用拉链法实现的，每个Entry本质上是一个单向链表
    private transient Entry[] table; // Hashtable中元素的实际数量
    private transient int count; // 阈值，用于判断是否须要调整Hashtable的容量（threshold = 容量*加载因子）
    private int threshold; // 加载因子
    private float loadFactor; // Hashtable被改变的次数
    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() { // 默认构造函数，指定的容量大小是11；加载因子是0.75
        this(11, 0.75f); } // 包含“子Map”的构造函数
    public Hashtable(Map<? extends K, ? extends V> t) { this(Math.max(2*t.size(), 11), 0.75f); // 将“子Map”的所有元素都添加到Hashtable中
 putAll(t); } public synchronized int size() { return count; } public synchronized boolean isEmpty() { return count == 0; } // 返回“全部key”的枚举对象
    public synchronized Enumeration<K> keys() { return this.<K>getEnumeration(KEYS); } // 返回“全部value”的枚举对象
    public synchronized Enumeration<V> elements() { return this.<V>getEnumeration(VALUES); } // 判断Hashtable是否包含“值(value)”
    public synchronized boolean contains(Object value) { // Hashtable中“键值对”的value不能是null， // 如果null的话，抛出异常!
        if (value == null) { throw new NullPointerException(); } // 从后向前遍历table数组中的元素(Entry) // 对于每一个Entry(单向链表)，逐个遍历，判断节点的值是否等于value
        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); } // 判断Hashtable是否包含key
    public synchronized boolean containsKey(Object key) { Entry tab[] = table; int hash = key.hashCode(); // 计算索引值， // % tab.length 的目的是防止数据越界
        int index = (hash & 0x7FFFFFFF) % tab.length; // 找到“key对应的Entry(链表)”，而后在链表中找出“哈希值”和“键值”与key都相等的元素
        for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { return true; } } return false; } // 返回key对应的value，没有的话返回null
    public synchronized V get(Object key) { Entry tab[] = table; int hash = key.hashCode(); // 计算索引值，
        int index = (hash & 0x7FFFFFFF) % tab.length; // 找到“key对应的Entry(链表)”，而后在链表中找出“哈希值”和“键值”与key都相等的元素
        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; } // 调整Hashtable的长度，将长度变成原来的(2倍+1) // (01) 将“旧的Entry数组”赋值给一个临时变量。 // (02) 建立一个“新的Entry数组”，并赋值给“旧的Entry数组” // (03) 将“Hashtable”中的所有元素依次添加到“新的Entry数组”中
    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; } } } // 将“key-value”添加到Hashtable中
    public synchronized V put(K key, V value) { // Hashtable中不能插入value为null的元素！！！
        if (value == null) { throw new NullPointerException(); } // 若“Hashtable中已存在键为key的键值对”， // 则用“新的value”替换“旧的value”
        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; } } // 若“Hashtable中不存在键为key的键值对”， // (01) 将“修改统计数”+1
        modCount++; // (02) 若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子) // 则调整Hashtable的大小
        if (count >= threshold) { // Rehash the table if the threshold is exceeded
 rehash(); tab = table; index = (hash & 0x7FFFFFFF) % tab.length; } // (03) 将“Hashtable中index”位置的Entry(链表)保存到e中
        Entry<K,V> e = tab[index]; // (04) 建立“新的Entry节点”，并将“新的Entry”插入“Hashtable的index位置”，并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。 
        tab[index] = new Entry<K,V>(hash, key, value, e); // (05) 将“Hashtable的实际容量”+1
        count++; return null; } // 删除Hashtable中键为key的元素
    public synchronized V remove(Object key) { Entry tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; // 找到“key对应的Entry(链表)” // 而后在链表中找出要删除的节点，并删除该节点。
        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; } // 将“Map(t)”的中所有元素逐一添加到Hashtable中
    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()); } // 清空Hashtable // 将Hashtable的table数组的值所有设为null
    public synchronized void clear() { Entry tab[] = table; modCount++; for (int index = tab.length; --index >= 0; ) tab[index] = null; count = 0; } // 克隆一个Hashtable，并以Object的形式返回。
    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) { // this shouldn't happen, since we are Cloneable
            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(", "); } } // 获取Hashtable的枚举类对象 // 若Hashtable的实际大小为0,则返回“空枚举类”对象； // 不然，返回正常的Enumerator的对象。(Enumerator实现了迭代器和枚举两个接口)
    private <T> Enumeration<T> getEnumeration(int type) { if (count == 0) { return (Enumeration<T>)emptyEnumerator; } else { return new Enumerator<T>(type, false); } } // 获取Hashtable的迭代器 // 若Hashtable的实际大小为0,则返回“空迭代器”对象； // 不然，返回正常的Enumerator的对象。(Enumerator实现了迭代器和枚举两个接口)
    private <T> Iterator<T> getIterator(int type) { if (count == 0) { return (Iterator<T>) emptyIterator; } else { return new Enumerator<T>(type, true); } } // Hashtable的“key的集合”。它是一个Set，意味着没有重复元素
    private transient volatile Set<K> keySet = null; // Hashtable的“key-value的集合”。它是一个Set，意味着没有重复元素
    private transient volatile Set<Map.Entry<K,V>> entrySet = null; // Hashtable的“key-value的集合”。它是一个Collection，意味着能够有重复元素
    private transient volatile Collection<V> values = null; // 返回一个被synchronizedSet封装后的KeySet对象 // synchronizedSet封装的目的是对KeySet的全部方法都添加synchronized，实现多线程同步
    public Set<K> keySet() { if (keySet == null) keySet = Collections.synchronizedSet(new KeySet(), this); return keySet; } // Hashtable的Key的Set集合。 // KeySet继承于AbstractSet，因此，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(); } } // 返回一个被synchronizedSet封装后的EntrySet对象 // synchronizedSet封装的目的是对EntrySet的全部方法都添加synchronized，实现多线程同步
    public Set<Map.Entry<K,V>> entrySet() { if (entrySet==null) entrySet = Collections.synchronizedSet(new EntrySet(), this); return entrySet; } // Hashtable的Entry的Set集合。 // EntrySet继承于AbstractSet，因此，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); } // 查找EntrySet中是否包含Object(0) // 首先，在table中找到o对应的Entry(Entry是一个单向链表) // 而后，查找Entry链表中是否存在Object
        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; } // 删除元素Object(0) // 首先，在table中找到o对应的Entry(Entry是一个单向链表) // 而后，删除链表中的元素Object
        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(); } } // 返回一个被synchronizedCollection封装后的ValueCollection对象 // synchronizedCollection封装的目的是对ValueCollection的全部方法都添加synchronized，实现多线程同步
    public Collection<V> values() { if (values==null) values = Collections.synchronizedCollection(new ValueCollection(), this); return values; } // Hashtable的value的Collection集合。 // ValueCollection继承于AbstractCollection，因此，ValueCollection中的元素能够重复的。
    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(); } } // 从新equals()函数 // 若两个Hashtable的全部key-value键值对都相等，则判断它们两个相等
    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 { // 经过迭代器依次取出当前Hashtable的key-value键值对 // 并判断该键值对，存在于Hashtable(o)中。 // 若不存在，则当即返回false；不然，遍历完“当前Hashtable”并返回true。
            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; } // 计算Hashtable的哈希值 // 若 Hashtable的实际大小为0 或者 加载因子<0，则返回0。 // 不然，返回“Hashtable中的每一个Entry的key和value的异或值 的总和”。
    public synchronized int hashCode() { int h = 0; if (count == 0 || loadFactor < 0) return h;  // Returns zero
 loadFactor = -loadFactor;  // Mark hashCode computation in progress
        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;  // Mark hashCode computation complete

        return h; } // java.io.Serializable的写入函数 // 将Hashtable的“总的容量，实际容量，全部的Entry”都写入到输出流中
    private synchronized void writeObject(java.io.ObjectOutputStream s) throws IOException { // Write out the length, threshold, loadfactor
 s.defaultWriteObject(); // Write out length, count of elements and then the key/value objects
 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; } } } // java.io.Serializable的读取函数：根据写入方式读出 // 将Hashtable的“总的容量，实际容量，全部的Entry”依次读出
    private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException { // Read in the length, threshold, and loadfactor
 s.defaultReadObject(); // Read the original length of the array and number of elements
        int origlength = s.readInt(); int elements = s.readInt(); // Compute new size with a bit of room 5% to grow but // no larger than the original size. Make the length // odd if it's large enough, this helps distribute the entries. // Guard against the length ending up zero, that's not valid.
        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; // Read the number of elements and then all the key/value objects
        for (; elements > 0; elements--) { K key = (K)s.readObject(); V value = (V)s.readObject(); // synch could be eliminated for performance
 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(); } // Makes sure the key is not already in the hashtable. // This should not happen in deserialized version.
        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(); } } // Creates the new entry.
        Entry<K,V> e = tab[index]; tab[index] = new Entry<K,V>(hash, key, value, e); count++; } // Hashtable的Entry节点，它本质上是一个单向链表。 // 也所以，咱们才能推断出Hashtable是由拉链法实现的散列表
    private static class Entry<K,V> implements Map.Entry<K,V> { // 哈希值
        int hash; K key; V value; // 指向的下一个Entry，即链表的下一个节点
        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; } // 设置value。若value是null，则抛出异常。
        public V setValue(V value) { if (value == null) throw new NullPointerException(); V oldValue = this.value; this.value = value; return oldValue; } // 覆盖equals()方法，判断两个Entry是否相等。 // 若两个Entry的key和value都相等，则认为它们相等。
        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; // Enumerator的做用是提供了“经过elements()遍历Hashtable的接口” 和 “经过entrySet()遍历Hashtable的接口”。由于，它同时实现了 “Enumerator接口”和“Iterator接口”。
    private class Enumerator<T> implements Enumeration<T>, Iterator<T> { // 指向Hashtable的table
        Entry[] table = Hashtable.this.table; // Hashtable的总的大小
        int index = table.length; Entry<K,V> entry = null; Entry<K,V> lastReturned = null; int type; // Enumerator是 “迭代器(Iterator)” 仍是 “枚举类(Enumeration)”的标志 // iterator为true，表示它是迭代器；不然，是枚举类。
        boolean iterator; // 在将Enumerator看成迭代器使用时会用到，用来实现fail-fast机制。
        protected int expectedModCount = modCount; Enumerator(int type, boolean iterator) { this.type = type; this.iterator = iterator; } // 从遍历table的数组的末尾向前查找，直到找到不为null的Entry。
        public boolean hasMoreElements() { Entry<K,V> e = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */
            while (e == null && i > 0) { e = t[--i]; } entry = e; index = i; return e != null; } // 获取下一个元素 // 注意：从hasMoreElements() 和nextElement() 能够看出“Hashtable的elements()遍历方式” // 首先，从后向前的遍历table数组。table数组的每一个节点都是一个单向链表(Entry)。 // 而后，依次向后遍历单向链表Entry。
        public T nextElement() { Entry<K,V> et = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */
            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"); } // 迭代器Iterator的判断是否存在下一个元素 // 实际上，它是调用的hasMoreElements()
        public boolean hasNext() { return hasMoreElements(); } // 迭代器获取下一个元素 // 实际上，它是调用的nextElement()
        public T next() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); return nextElement(); } // 迭代器的remove()接口。 // 首先，它在table数组中找出要删除元素所在的Entry， // 而后，删除单向链表Entry中的元素。
        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(); // 空枚举类 // 当Hashtable的实际大小为0；此时，又要经过Enumeration遍历Hashtable时，返回的是“空枚举类”的对象。
    private static class EmptyEnumerator implements Enumeration<Object> { EmptyEnumerator() { } // 空枚举类的hasMoreElements() 始终返回false
        public boolean hasMoreElements() { return false; } // 空枚举类的nextElement() 抛出异常
        public Object nextElement() { throw new NoSuchElementException("Hashtable Enumerator"); } } // 空迭代器 // 当Hashtable的实际大小为0；此时，又要经过迭代器遍历Hashtable时，返回的是“空迭代器”的对象。
    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"); } } }

View Code

　　说明: 在详细介绍Hashtable的代码以前，咱们须要了解：和Hashmap同样，Hashtable也是一个散列表，它也是经过“拉链法”解决哈希冲突的。
第3.1部分 Hashtable的“拉链法”相关内容数据结构

3.1.1数据节点Entry的数据结构多线程

 1 private static class Entry<K,V> implements Map.Entry<K,V> {  2     // 哈希值
 3     int hash;  4  K key;  5  V value;  6     // 指向的下一个Entry，即链表的下一个节点
 7     Entry<K,V> next;  8 
 9     // 构造函数
10     protected Entry(int hash, K key, V value, Entry<K,V> next) { 11         this.hash = hash; 12         this.key = key; 13         this.value = value; 14         this.next = next; 15  } 16 
17     protected Object clone() { 18         return new Entry<K,V>(hash, key, value, 19               (next==null ? null : (Entry<K,V>) next.clone())); 20  } 21 
22     public K getKey() { 23         return key; 24  } 25 
26     public V getValue() { 27         return value; 28  } 29 
30     // 设置value。若value是null，则抛出异常。
31     public V setValue(V value) { 32         if (value == null) 33             throw new NullPointerException(); 34 
35         V oldValue = this.value; 36         this.value = value; 37         return oldValue; 38  } 39 
40     // 覆盖equals()方法，判断两个Entry是否相等。 41     // 若两个Entry的key和value都相等，则认为它们相等。
42     public boolean equals(Object o) { 43         if (!(o instanceof Map.Entry)) 44             return false; 45         Map.Entry e = (Map.Entry)o; 46 
47         return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
48            (value==null ? e.getValue()==null : value.equals(e.getValue())); 49  } 50 
51     public int hashCode() { 52         return hash ^ (value==null ? 0 : value.hashCode()); 53  } 54 
55     public String toString() { 56         return key.toString()+"="+value.toString(); 57  } 58 }

View Code

　　从中，咱们能够看出Entry实际上就是一个单向链表。这也是为何咱们说Hashtable是经过拉链法解决哈希冲突的。Entry 实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数。这些都是基本的读取/修改key、value值的函数。app

第3.2部分 Hashtable的构造函数ide

 1 // 默认构造函数。
 2 public Hashtable() {  3     // 默认构造函数，指定的容量大小是11；加载因子是0.75
 4     this(11, 0.75f);  5 }  6 
 7 // 指定“容量大小”的构造函数
 8 public Hashtable(int initialCapacity) {  9     this(initialCapacity, 0.75f); 10 } 11 
12 // 指定“容量大小”和“加载因子”的构造函数
13 public Hashtable(int initialCapacity, float loadFactor) { 14     if (initialCapacity < 0) 15         throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); 16     if (loadFactor <= 0 || Float.isNaN(loadFactor)) 17         throw new IllegalArgumentException("Illegal Load: "+loadFactor); 18 
19     if (initialCapacity==0) 20         initialCapacity = 1; 21     this.loadFactor = loadFactor; 22     table = new Entry[initialCapacity]; 23     threshold = (int)(initialCapacity * loadFactor); 24 } 25 
26 // 包含“子Map”的构造函数
27 public Hashtable(Map<? extends K, ? extends V> t) { 28     this(Math.max(2*t.size(), 11), 0.75f); 29     // 将“子Map”的所有元素都添加到Hashtable中
30  putAll(t); 31 }

View Code

第3.3部分 Hashtable的主要对外接口函数

　　3.3.1 clear()oop

　　clear() 的做用是清空Hashtable。它是将Hashtable的table数组的值所有设为null

1 public synchronized void clear() { 2     Entry tab[] = table; 3     modCount++; 4     for (int index = tab.length; --index >= 0; ) 5         tab[index] = null; 6     count = 0; 7 }

View Code

　　3.3.2 contains() 和 containsValue()

　　contains() 和 containsValue() 的做用都是判断Hashtable是否包含"值(value)"

 1 public boolean containsValue(Object value) {  2     return contains(value);  3 }  4 
 5 public synchronized boolean contains(Object value) {  6     // Hashtable中“键值对”的value不能是null，  7     // 如果null的话，抛出异常!
 8     if (value == null) {  9         throw new NullPointerException(); 10  } 11 
12     // 从后向前遍历table数组中的元素(Entry) 13     // 对于每一个Entry(单向链表)，逐个遍历，判断节点的值是否等于value
14     Entry tab[] = table; 15     for (int i = tab.length ; i-- > 0 ;) { 16         for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) { 17             if (e.value.equals(value)) { 18                 return true; 19  } 20  } 21  } 22     return false; 23 }

View Code

　　3.3.3 containsKey()

　　containsKey() 的做用是判断Hashtable是否包含key

 1 public synchronized boolean containsKey(Object key) {  2     Entry tab[] = table;  3     int hash = key.hashCode();  4     // 计算索引值，  5     // % tab.length 的目的是防止数据越界
 6     int index = (hash & 0x7FFFFFFF) % tab.length;  7     // 找到“key对应的Entry(链表)”，而后在链表中找出“哈希值”和“键值”与key都相等的元素
 8     for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {  9         if ((e.hash == hash) && e.key.equals(key)) { 10             return true; 11  } 12  } 13     return false; 14 }

View Code

　　3.3.4 elements()

　　elements() 的做用是返回“全部value”的枚举对象

 1 public synchronized Enumeration<V> elements() {  2     return this.<V>getEnumeration(VALUES);  3 }  4 
 5 // 获取Hashtable的枚举类对象
 6 private <T> Enumeration<T> getEnumeration(int type) {  7     if (count == 0) {  8         return (Enumeration<T>)emptyEnumerator;  9     } else { 10         return new Enumerator<T>(type, false); 11  } 12 }

View Code

　　从中，咱们能够看出：
　　(01) 若Hashtable的实际大小为0,则返回“空枚举类”对象emptyEnumerator；
　　(02) 不然，返回正常的Enumerator的对象。(Enumerator实现了迭代器和枚举两个接口)

　　咱们先看看emptyEnumerator对象是如何实现的

 1 private static Enumeration emptyEnumerator = new EmptyEnumerator();  2 //空枚举类  3 //当Hashtable的实际大小为0；此时，又要经过Enumeration遍历Hashtable时，返回的是“空枚举类”的对象。
 4 private static class EmptyEnumerator implements Enumeration<Object> {  5  EmptyEnumerator() {  6  }  7     // 空枚举类的hasMoreElements() 始终返回false
 8     public boolean hasMoreElements() {  9         return false; 10  } 11     // 空枚举类的nextElement() 抛出异常
12     public Object nextElement() { 13         throw new NoSuchElementException("Hashtable Enumerator"); 14  } 15 }

View Code

　　咱们在来看看Enumeration类Enumerator的做用是提供了“经过elements()遍历Hashtable的接口”和“经过entrySet()遍历Hashtable的接口”。由于，它同时实现了 “Enumerator接口”和“Iterator接口”。

 1 private class Enumerator<T> implements Enumeration<T>,Iterator<T>{  2     // 指向Hashtable的table
 3     Entry[] table = Hashtable.this.table;  4     //Hashtable的总的大小
 5     int index = table.length;  6     Entry<K,V> entry = null;  7     Entry<K,V> lastReturned = null;  8     int type;  9     //Enumerator是 “迭代器(Iterator)” 仍是 “枚举类(Enumeration)”的标志 10     //iterator为true，表示它是迭代器；不然，是枚举类。
11     boolean iterator; 12     // 在将Enumerator看成迭代器使用时会用到，用来实现fail-fast机制。
13     protected int expectedModCount = modCount; 14     Enumerator(int type, boolean iterator) { 15         this.type = type; 16         this.iterator = iterator; 17  } 18     //从遍历table的数组的末尾向前查找，直到找到不为null的Entry。
19     public boolean hasMoreElements() { 20         Entry<K,V> e = entry; 21         int i = index; 22         Entry[] t = table; 23         /* Use locals for faster loop iteration */
24         while (e == null && i > 0) { 25             e = t[--i]; 26  } 27         entry = e; 28         index = i; 29         return e != null; 30  } 31 
32     //获取下一个元素 33     //注意：从hasMoreElements() 和nextElement() 能够看出“Hashtable的elements()遍历方式” 34     //首先，从后向前的遍历table数组。table数组的每一个节点都是一个单向链表(Entry)。 35     //而后，依次向后遍历单向链表Entry。
36     public T nextElement() { 37         Entry<K,V> et = entry; 38         int i = index; 39         Entry[] t = table; 40         /* Use locals for faster loop iteration */
41         while (et == null && i > 0) { 42             et = t[--i]; 43  } 44         entry = et; 45         index = i; 46         if (et != null) { 47             Entry<K,V> e = lastReturned = entry; 48             entry = e.next; 49             return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e); 50  } 51         throw new NoSuchElementException("Hashtable Enumerator"); 52  } 53 
54     //迭代器Iterator的判断是否存在下一个元素 55     //实际上，它是调用的hasMoreElements()
56     public boolean hasNext() { 57         return hasMoreElements(); 58  } 59 
60     //迭代器获取下一个元素 61     //实际上，它是调用的nextElement()
62     public T next() { 63         if (modCount != expectedModCount) 64             throw new ConcurrentModificationException(); 65         return nextElement(); 66  } 67 
68     //迭代器的remove()接口。 69     //首先，它在table数组中找出要删除元素所在的Entry， 70     //而后，删除单向链表Entry中的元素。
71     public void remove() { 72         if (!iterator) 73             throw new UnsupportedOperationException(); 74         if (lastReturned == null) 75             throw new IllegalStateException("Hashtable Enumerator"); 76         if (modCount != expectedModCount) 77             throw new ConcurrentModificationException(); 78         synchronized(Hashtable.this) { 79             Entry[] tab = Hashtable.this.table; 80             int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length; 81 
82             for (Entry<K,V> e = tab[index], prev = null; e != null; 83                  prev = e, e = e.next) { 84                 if (e == lastReturned) { 85                     modCount++; 86                     expectedModCount++; 87                     if (prev == null) 88                         tab[index] = e.next; 89                     else
90                         prev.next = e.next; 91                     count--; 92                     lastReturned = null; 93                     return; 94  } 95  } 96             throw new ConcurrentModificationException(); 97  } 98  } 99 }

View Code

　　entrySet(), keySet(), keys(), values()的实现方法和elements()差很少，并且源码中已经明确的给出了注释。这里就再也不作过多说明了。

　　3.3.5 get()

　　get() 的做用就是获取key对应的value，没有的话返回null

 1 public synchronized V get(Object key) { 2     Entry tab[] = table; 3     int hash = key.hashCode(); 4     // 计算索引值，
 5     int index = (hash & 0x7FFFFFFF) % tab.length; 6     // 找到“key对应的Entry(链表)”，而后在链表中找出“哈希值”和“键值”与key都相等的元素
 7     for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) { 8         if ((e.hash == hash) && e.key.equals(key)) { 9             return e.value; 10 } 11 } 12     return null; 13 }

View Code

　　3.3.6 put()

　　put() 的做用是对外提供接口，让Hashtable对象能够经过put()将“key-value”添加到Hashtable中。

 1 public synchronized V put(K key, V value) { 2     // Hashtable中不能插入value为null的元素！！！
 3     if (value == null) { 4         throw new NullPointerException(); 5 } 7     // 若“Hashtable中已存在键为key的键值对”，
 8     // 则用“新的value”替换“旧的value”
 9     Entry tab[] = table; 10     int hash = key.hashCode(); 11     int index = (hash & 0x7FFFFFFF) % tab.length; 12     for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) { 13         if ((e.hash == hash) && e.key.equals(key)) { 14             V old = e.value; 15             e.value = value; 16             return old; 17 } 18 } 20     // 若“Hashtable中不存在键为key的键值对”，
21     // (01) 将“修改统计数”+1
22     modCount++; 23     // (02) 若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)
24     // 则调整Hashtable的大小
25     if (count >= threshold) { 26         // Rehash the table if the threshold is exceeded
27 rehash(); 28 
29         tab = table; 30         index = (hash & 0x7FFFFFFF) % tab.length; 31 } 32 
33     // (03) 将“Hashtable中index”位置的Entry(链表)保存到e中
34     Entry<K,V> e = tab[index]; 35     //(04) 建立“新的Entry节点”，并将“新的Entry”插入“Hashtable的index位、置”，并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。 
36     tab[index] = new Entry<K,V>(hash, key, value, e); 37     // (05) 将“Hashtable的实际容量”+1
38     count++; 39     return null; 40 }

View Code

　　3.3.7 putAll()

　　putAll() 的做用是将“Map(t)”的中所有元素逐一添加到Hashtable中

1 public synchronized void putAll(Map<? extends K, ? extends V> t) { 2     for (Map.Entry<? extends K, ? extends V> e : t.entrySet()) 3 put(e.getKey(), e.getValue()); 4 }

View Code

　　3.3.8 remove()

　　remove() 的做用就是删除Hashtable中键为key的元素

 1 public synchronized V remove(Object key) {  2     Entry tab[] = table;  3     int hash = key.hashCode();  4     int index = (hash & 0x7FFFFFFF) % tab.length;  5     // 找到“key对应的Entry(链表)”  6     // 而后在链表中找出要删除的节点，并删除该节点。
 7     for (Entry<K,V> e = tab[index],prev=null ; e!=null;prev=e,e= e.next) {  8         if ((e.hash == hash) && e.key.equals(key)) {  9             modCount++; 10             if (prev != null) { 11                 prev.next = e.next; 12             } else { 13                 tab[index] = e.next; 14  } 15             count--; 16             V oldValue = e.value; 17             e.value = null; 18             return oldValue; 19  } 20  } 21     return null; 22 }

View Code

第3.4部分 Hashtable实现的Cloneable接口

　　Hashtable实现了Cloneable接口，即实现了clone()方法。
　　clone()方法的做用很简单，就是克隆一个Hashtable对象并返回。

 1 // 克隆一个Hashtable，并以Object的形式返回。
 2 public synchronized Object clone() {  3     try {  4         Hashtable<K,V> t = (Hashtable<K,V>) super.clone();  5         t.table = new Entry[table.length];  6         for (int i = table.length ; i-- > 0 ; ) {  7             t.table[i] = (table[i] != null)  8             ? (Entry<K,V>) table[i].clone() : null;  9  } 10         t.keySet = null; 11         t.entrySet = null; 12         t.values = null; 13         t.modCount = 0; 14         return t; 15     } catch (CloneNotSupportedException e) { 16         // this shouldn't happen, since we are Cloneable
17         throw new InternalError(); 18  } 19 }

View Code

第3.5部分 Hashtable实现的Serializable接口

　　Hashtable实现java.io.Serializable，分别实现了串行读取、写入功能。串行写入函数就是将Hashtable的“总的容量，实际容量，全部的Entry”都写入到输出流中.串行读取函数：根据写入方式读出将Hashtable的“总的容量，实际容量，全部的Entry”依次读出

private synchronized void writeObject(java.io.ObjectOutputStream s)
    throws IOException
{
    // Write out the length, threshold, loadfactor
    s.defaultWriteObject();

    // Write out length, count of elements and then the key/value objects
    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
{
    // Read in the length, threshold, and loadfactor
    s.defaultReadObject();

    // Read the original length of the array and number of elements
    int origlength = s.readInt();
    int elements = s.readInt();

    // Compute new size with a bit of room 5% to grow but
    // no larger than the original size.  Make the length
    // odd if it's large enough, this helps distribute the entries.
    // Guard against the length ending up zero, that's not valid.
    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;

    // Read the number of elements and then all the key/value objects
    for (; elements > 0; elements--) {
        K key = (K)s.readObject();
        V value = (V)s.readObject();
            // synch could be eliminated for performance
            reconstitutionPut(table, key, value);
    }
    this.table = table;
}

View Code

第4部分 Hashtable遍历方式

　　4.1 遍历Hashtable的键值对

　　第一步：根据entrySet()获取Hashtable的“键值对”的Set集合。
　　第二步：经过Iterator迭代器遍历“第一步”获得的集合。

 1 // 假设table是Hashtable对象  2 // table中的key是String类型，value是Integer类型
 3 Integer integ = null;  4 Iterator iter = table.entrySet().iterator();  5 while(iter.hasNext()) {  6     Map.Entry entry = (Map.Entry)iter.next();  7     // 获取key
 8     key = (String)entry.getKey();  9         // 获取value
10     integ = (Integer)entry.getValue(); 11 }

View Code

4.2 经过Iterator遍历Hashtable的键

　　第一步：根据keySet()获取Hashtable的“键”的Set集合。
　　第二步：经过Iterator迭代器遍历“第一步”获得的集合。

 1 //假设table是Hashtable对象  2 //table中的key是String类型，value是Integer类型
 3 String key = null;  4 Integer integ = null;  5 Iterator iter = table.keySet().iterator();  6 while (iter.hasNext()) {  7         // 获取key
 8     key = (String)iter.next();  9         // 根据key，获取value
10     integ = (Integer)table.get(key); 11 }

View Code

4.3 经过Iterator遍历Hashtable的值

　　第一步：根据value()获取Hashtable的“值”的集合。
　　第二步：经过Iterator迭代器遍历“第一步”获得的集合。

1 // 假设table是Hashtable对象 2 // table中的key是String类型，value是Integer类型
3 Integer value = null; 4 Collection c = table.values(); 5 Iterator iter= c.iterator(); 6 while (iter.hasNext()) { 7     value = (Integer)iter.next(); 8 }

View Code

4.4 经过Enumeration遍历Hashtable的键

　　第一步：根据keys()获取Hashtable的集合。
　　第二步：经过Enumeration遍历“第一步”获得的集合。

1 Enumeration enu = table.keys(); 2 while(enu.hasMoreElements()) { 3  System.out.println(enu.nextElement()); 4 }

View Code

4.5 经过Enumeration遍历Hashtable的值

　　第一步：根据elements()获取Hashtable的集合。
　　第二步：经过Enumeration遍历“第一步”获得的集合。

1 Enumeration enu = table.keys(); 2 while(enu.hasMoreElements()) { 3  System.out.println(enu.nextElement()); 4 }

View Code