java容器类---Hashtable

1、Hashtable简介

(1)Hashtable同样是基于哈希表实现的，同样每个元素是一个key-value对，其内部也是通过单链表解决冲突问题，容量不足（超过了阀值）时，同样会自动增长。

(2)Hashtable也是JDK1.0引入的类，是线程安全的，能用于多线程环境中。

(3)Hashtable同样实现了Serializable接口，它支持序列化，实现了Cloneable接口，能被克隆。

 
Hashtable 和HashMap 存储结构和解决冲突的方法都是相同的。(详见：java容器类---HashMap、HashSet)
 
Hashtable继承关系：
[java] view plain copy
 
  1. public class Hashtable<K,V>      
  2.     extends Dictionary<K,V>      
  3.     implements Map<K,V>, Cloneable, java.io.Serializable   

2、Hashtable 成员变量
[java] view plain copy
 
  1. // 保存key-value的数组。      
  2. // Hashtable同样采用单链表解决冲突，每一个Entry本质上是一个单向链表      
  3. private transient Entry[] table;      
  4.   
  5. // Hashtable中键值对的数量      
  6. private transient int count;      
  7.   
  8. // 阈值，用于判断是否需要调整Hashtable的容量（threshold = 容量*加载因子）      
  9. private int threshold;      
  10.   
  11. // 加载因子      
  12. private float loadFactor;      
  13.   
  14. // Hashtable被改变的次数，用于fail-fast机制的实现      
  15. private transient int modCount = 0;       
[java] view plain copy
 
  1.    // Hashtable的Entry节点，它本质上是一个单向链表。      
  2.    // 也因此，我们才能推断出Hashtable是由拉链法实现的散列表      
  3.    private static class Entry<K,V> implements Map.Entry<K,V> {      
  4.        // 哈希值      
  5.        int hash;      
  6.        K key;      
  7.        V value;      
  8.        // 指向的下一个Entry，即链表的下一个节点      
  9.        Entry<K,V> next;      
  10.     
  11.        // 构造函数      
  12.        protected Entry(int hash, K key, V value, Entry<K,V> next) {      
  13.            this.hash = hash;      
  14.            this.key = key;      
  15.            this.value = value;      
  16.            this.next = next;      
  17.        }     
  18. ....  
  19. }  
3、Hashtable构造函数
[java] view plain copy
 
  1. // 指定“容量大小”和“加载因子”的构造函数      
  2. public Hashtable(int initialCapacity, float loadFactor) {      
  3.     if (initialCapacity < 0)      
  4.         throw new IllegalArgumentException("Illegal Capacity: "+      
  5.                                            initialCapacity);      
  6.     if (loadFactor <= 0 || Float.isNaN(loadFactor))      
  7.         throw new IllegalArgumentException("Illegal Load: "+loadFactor);      
  8.     if (initialCapacity==0)      
  9.         initialCapacity = 1;      
  10.     this.loadFactor = loadFactor;      
  11.     table = new Entry[initialCapacity];      
  12.     threshold = (int)(initialCapacity * loadFactor);      
  13. }      
  14. // 指定“容量大小”的构造函数      
  15. public Hashtable(int initialCapacity) {      
  16.     this(initialCapacity, 0.75f);      
  17. }      
  18. // 默认构造函数。      
  19. public Hashtable() {      
  20.     // 默认构造函数，指定的容量大小是11；加载因子是0.75      
  21.     this(11, 0.75f);      
  22. }      
  23. // 包含“子Map”的构造函数      
  24. public Hashtable(Map<? extends K, ? extends V> t) {      
  25.     this(Math.max(2*t.size(), 11), 0.75f);      
  26.     // 将“子Map”的全部元素都添加到Hashtable中      
  27.     putAll(t);      
  28. }  
4、Hashtable常用方法
4.1 put方法
[java] view plain copy
 
  1. // 调整Hashtable的长度，将长度变成原来的2倍+1     
  2.   protected void rehash() {      
  3.       int oldCapacity = table.length;      
  4.       Entry[] oldMap = table;      
  5.    
  6.       //创建新容量大小的Entry数组    
  7.       int newCapacity = oldCapacity * 2 + 1;      
  8.       Entry[] newMap = new Entry[newCapacity];      
  9.    
  10.       modCount++;      
  11.       threshold = (int)(newCapacity * loadFactor);      
  12.       table = newMap;      
  13.           
  14.       //将“旧的Hashtable”中的元素复制到“新的Hashtable”中    
  15.       for (int i = oldCapacity ; i-- > 0 ;) {      
  16.           for (Entry<K,V> old = oldMap[i] ; old != null ; ) {      
  17.               Entry<K,V> e = old;      
  18.               old = old.next;      
  19.               //重新计算index    
  20.               int index = (e.hash & 0x7FFFFFFF) % newCapacity;      
  21.               e.next = newMap[index];      
  22.               newMap[index] = e;      
  23.           }      
  24.       }      
  25.   }      
  26.    
  27.   // 将“key-value”添加到Hashtable中      
  28.   public synchronized V put(K key, V value) {      
  29.       // Hashtable中不能插入value为null的元素！！！  
  30.       if (value == null) {      
  31.           throw new NullPointerException();      
  32.       }      
  33.    
  34.       // 若“Hashtable中已存在键为key的键值对”，      
  35.       // 则用“新的value”替换“旧的value”      
  36.       Entry tab[] = table;      
  37.       int hash = key.hashCode();      
  38.       int index = (hash & 0x7FFFFFFF) % tab.length;      
  39.       for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {      
  40.           if ((e.hash == hash) && e.key.equals(key)) {      
  41.               V old = e.value;      
  42.               e.value = value;      
  43.               return old;      
  44.               }      
  45.       }      
  46.    
  47.       // 若“Hashtable中不存在键为key的键值对”，    
  48.       // 将“修改统计数”+1      
  49.       modCount++;      
  50.       //  若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)      
  51.       //  则调整Hashtable的大小      
  52.       if (count >= threshold) {    
  53.           rehash();      
  54.    
  55.           tab = table;      
  56.           index = (hash & 0x7FFFFFFF) % tab.length;      
  57.       }      
  58.    
  59.       //将新的key-value对插入到tab[index]处（即链表的头结点）    
  60.       Entry<K,V> e = tab[index];             
  61.       tab[index] = new Entry<K,V>(hash, key, value, e);      
  62.       count++;      
  63.       return null;      
  64.   }    
4.2 get 方法
[java] view plain copy
 
  1. // 返回key对应的value，没有的话返回null      
  2.  public synchronized V get(Object key) {      
  3.      Entry tab[] = table;      
  4.      int hash = key.hashCode();      
  5.      // 计算索引值，      
  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 e.value;      
  11.          }      
  12.      }      
  13.      return null;      
  14.  }     
4.3 remove 方法
[java] view plain copy
 
  1. // 删除Hashtable中键为key的元素      
  2. public synchronized V remove(Object key) {      
  3.     Entry tab[] = table;      
  4.     int hash = key.hashCode();      
  5.     int index = (hash & 0x7FFFFFFF) % tab.length;      
  6.         
  7.     //从table[index]链表中找出要删除的节点，并删除该节点。    
  8.     //因为是单链表，因此要保留带删节点的前一个节点，才能有效地删除节点    
  9.     for (Entry<K,V> e = tab[index], prev = null ; e != null ; prev = e, e = e.next) {      
  10.         if ((e.hash == hash) && e.key.equals(key)) {      
  11.             modCount++;      
  12.             if (prev != null) {      
  13.                 prev.next = e.next;      
  14.             } else {      
  15.                 tab[index] = e.next;      
  16.             }      
  17.             count--;      
  18.             V oldValue = e.value;      
  19.             e.value = null;      
  20.             return oldValue;      
  21.         }      
  22.     }      
  23.     return null;      
  24. }   
5、Hashtable的Iterator
[java] view plain copy
 
  1.    // 获取Hashtable的枚举类对象      
  2.    // 若Hashtable的实际大小为0,则返回“空枚举类”对象；      
  3.    // 否则，返回正常的Enumerator的对象。     
  4.    private <T> Enumeration<T> getEnumeration(int type) {      
  5.    if (count == 0) {      
  6.        return (Enumeration<T>)emptyEnumerator;      
  7.    } else {      
  8.        return new Enumerator<T>(type, false);      
  9.    }      
  10.    }      
  11.    // 获取Hashtable的迭代器      
  12.    // 若Hashtable的实际大小为0,则返回“空迭代器”对象；      
  13.    // 否则，返回正常的Enumerator的对象。(Enumerator实现了迭代器和枚举两个接口)      
  14.    private <T> Iterator<T> getIterator(int type) {      
  15.        if (count == 0) {      
  16.            return (Iterator<T>) emptyIterator;      
  17.        } else {      
  18.            return new Enumerator<T>(type, true);      
  19.        }      
  20.    }     
  21.    // Enumerator的作用是提供了“通过elements()遍历Hashtable的接口” 和 “通过entrySet()遍历Hashtable的接口”。      
  22.    private class Enumerator<T> implements Enumeration<T>, Iterator<T> {      
  23.        // 指向Hashtable的table      
  24.        Entry[] table = Hashtable.this.table;      
  25.        // Hashtable的总的大小      
  26.        int index = table.length;      
  27.        Entry<K,V> entry = null;      
  28.        Entry<K,V> lastReturned = null;      
  29.        int type;      
  30.     
  31.        // Enumerator是 “迭代器(Iterator)” 还是 “枚举类(Enumeration)”的标志      
  32.        // iterator为true，表示它是迭代器；否则，是枚举类。      
  33.        boolean iterator;      
  34.     
  35.        // 在将Enumerator当作迭代器使用时会用到，用来实现fail-fast机制。      
  36.        protected int expectedModCount = modCount;      
  37.     
  38.        Enumerator(int type, boolean iterator) {      
  39.            this.type = type;      
  40.            this.iterator = iterator;      
  41.        }      
  42.     
  43.        // 从遍历table的数组的末尾向前查找，直到找到不为null的Entry。      
  44.        public boolean hasMoreElements() {      
  45.            Entry<K,V> e = entry;      
  46.            int i = index;      
  47.            Entry[] t = table;      
  48.            /* Use locals for faster loop iteration */     
  49.            while (e == null && i > 0) {      
  50.                e = t[--i];      
  51.            }      
  52.            entry = e;      
  53.            index = i;      
  54.            return e != null;      
  55.        }      
  56.     
  57.        // 获取下一个元素      
  58.        // 注意：从hasMoreElements() 和nextElement() 可以看出“Hashtable的elements()遍历方式”      
  59.        // 首先，<span style="color:#ff0000;">从后向前的遍历table数组</span>。table数组的每个节点都是一个单向链表(Entry)。      
  60.        // 然后，依次向后遍历单向链表Entry。      
  61.        public T nextElement() {      
  62.            Entry<K,V> et = entry;      
  63.            int i = index;      
  64.            Entry[] t = table;      
  65.            /* Use locals for faster loop iteration */     
  66.            while (et == null && i > 0) {      
  67.                et = t[--i];      
  68.            }      
  69.            entry = et;      
  70.            index = i;      
  71.            if (et != null) {      
  72.                Entry<K,V> e = lastReturned = entry;      
  73.                entry = e.next;      
  74.                return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);      
  75.            }      
  76.            throw new NoSuchElementException("Hashtable Enumerator");      
  77.        }   
  78.   
  79. ...  
  80. }  

6、总结
Hashtable和HashMap不同之处
1、继承不同。我们从他们的定义就可以看出他们的不同，HashTable基于Dictionary类，而HashMap是基于AbstractMap。
 
2、默认容量及扩容方式不同。HashTable在不指定容量的情况下的默认容量为11，而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。Hashtable扩容时，将容量变为原来的2倍加1，而HashMap扩容时，将容量变为原来的2倍。
 
3、Hashtable中key和value都不允许为null，而HashMap中key和value都允许为null（key只能有一个为null，而value则可以有多个为null）。当get()方法返回null值时，即可以表示 HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键， 而应该用containsKey()方法来判断。如下：当HashMap遇到为null的key时，它会调用putForNullKey方法来进行处理。对于value没有进行任何处理，只要是对象都可以。
 
4、hash值的计算方式不同。Hashtable计算hash值，直接用key的hashCode()，而HashMap重新计算了key的hash值，Hashtable在求hash值对应的位置索引时，用取模运算，而HashMap在求位置索引时，则用与运算，且这里一般先用hash&0x7FFFFFFF后，再对length取模，&0x7FFFFFFF的目的是为了将负的hash值转化为正值，因为hash值有可能为负数，而&0x7FFFFFFF后，只有符号外改变，而后面的位都不变。
 
5、线程安全性不同。Hashtable的很多方法是同步的，线程安全的。HashMap未经同步，非线程安全。
 
6、两个遍历方式的内部实现上不同。Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式 。
 
相同之处：
Hashtable和HashMap对象可以让你把一个key和一个value结合起来，并用put() 方法把这对key/value输入到表中。然后你可以通过调用get()方法，把key作为参数来得到这个value（值）。二者的存储结构和解决冲突的方法都是相同的。

参考来源：
posted @ 2016-12-09 17:35  天涯海角路  阅读(194)  评论(0)    收藏  举报