Hashtable

关注

原创最新推荐文章于 2026-03-31 04:00:55 发布 806 阅读 AI 写同款· GEO 优化 ›

Linux:Hashlist/hashtable: [积木] 文章目录DEFINE_HASHTABLE使用实例 DEFINE_HASHTABLE struct hlist_head { struct hlist_node *first; }; struct hlist_node { struct hlist_node *next, **pprev; }; #define HLIST_HEAD_INIT { .first = NULL } #define DEFINE_HASHTABLE(name, bits) \ 定义一个hash表，名称，以及阅读详情

一.概述

1.定义

Hashtable类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。
HashMap是Hashtable的轻量级实现。
Hashtable定义：

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

HashMap定义：

public class HashMap<K,V>
         extends AbstractMap<K,V>
         implements Map<K,V>, Cloneable, Serializable

Hashtable是基于陈旧的Dictionary类的，HashMap是 Java 1.2引进的Map接口的一个实现。
Hashtable也是继承了Map接口。它们的不同是 Hashtable（since JDK1.0）就继承了Dictionary这个抽象类，而HashMap（since JDK1.2）继承的则是AbstractMap这个抽象类。因为在Hashtable中看到继承Map后所实现的方法是JDK1.2版本时加上去的，估计是在JDK 1.2开发时出于统一的考虑使得Hashtable也继承了Map接口。

2.重要参数

(1)table

为一个Entry[]数组类型，Entry代表了“拉链”的节点，每一个Entry代表了一个键值对，哈希表的”key-value键值对”都是存储在Entry数组中的。

(2)count

HashTable的大小，这个大小并不是HashTable的容器大小，而是他所包含Entry键值对的数量。

(3)threshold

Hashtable的阈值，用于判断是否需要调整Hashtable的容量。
threshold的值=容量count * 加载因子loadFactor。

(4)loadFactor

加载因子。

(5)modCount

用来实现“fail-fast”机制的（也就是快速失败）。所谓快速失败就是在并发集合中，其进行迭代操作时，若有其他线程对其进行结构性的修改，这时迭代器会立马感知到，并且立即抛出ConcurrentModificationException异常，而不是等到迭代完成之后才告诉你（你已经出错了）。

二.构造函数

1.Hashtable()

初始大小为11（Hashmap桶的初始大小为16）

public Hashtable() {
  this(11, 0.75f);
}

2.Hashtable(int initialCapacity)

自定义初始化的容量大小和默认的加载因子 (0.75) 构造一个新的空哈希表。

public Hashtable(int initialCapacity) {
  this(initialCapacity, 0.75f);
}

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，获得大小为initialCapacity的table数组
       table = new Entry[initialCapacity];
       //计算阀值
       threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
       //初始化HashSeed值
       initHashSeedAsNeeded(initialCapacity);
   }

initHashSeedAsNeeded方法用于初始化hashSeed参数，其中hashSeed用于计算key的hash值，它与key的hashCode进行按位异或运算。这个hashSeed是一个与实例相关的随机值，主要用于解决hash冲突。

private int hash(Object k) {
     return hashSeed ^ k.hashCode();
}

3.Hashtable(Map map)

构造一个与给定的 Map 具有相同映射关系的新哈希表。

public Hashtable(Map<? extends K, ? extends V> t) {
   //设置table容器大小，其值==t.size * 2 + 1
     this(Math.max(2*t.size(), 11), 0.75f);
     putAll(t);
 }

三.主要方法

1.put(K key, V value)

put方法的整个处理流程是：计算key的hash值，根据hash值获得key在table数组中的索引位置，然后迭代该key处的Entry链表（我们暂且理解为链表），若该链表中存在一个这个的key值，那么就直接替换其value值即可，否则在将该key-value节点插入该index索引位置处。

//同步
public synchronized V put(K key, V value) {
    // 不允许value为null
      if (value == null) {
          throw new NullPointerException();
      }

      /*
       * 确保key在table[]是不重复的
       * 处理过程：
       * 1、计算key的hash值，确认在table[]中的索引位置
       * 2、迭代index索引位置，如果该位置处的链表中存在一个一样的key，则替换其value，返回旧值
       */
      Entry tab[] = table;
      int hash = hash(key);    //计算key的hash值
      //寻找该key的索引位置
      //hash & 0x7FFFFFFF为确保结果hash值为正，然后对table.length取余找到位置
      int index = (hash & 0x7FFFFFFF) % tab.length;     
      //迭代，寻找该key，替换
      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;
          hash = hash(key);
          index = (hash & 0x7FFFFFFF) % tab.length;
      }

      // 在索引位置处插入一个新的节点
      Entry<K,V> e = tab[index];
      tab[index] = new Entry<>(hash, key, value, e);
      //容器中元素+1
      count++;
      return null;
  }

2.rehash()

HashTable的扩容操作，在put方法中，如果需要向table[]中添加Entry元素，会首先进行容量校验，如果容量已经达到了阀值，HashTable就会进行扩容处理rehash()，扩大为新容量=旧容量 * 2 + 1

protected void rehash() {
      int oldCapacity = table.length;
       //元素
       Entry<K,V>[] oldMap = table;

       //新容量=旧容量 * 2 + 1
       int newCapacity = (oldCapacity << 1) + 1;
       if (newCapacity - MAX_ARRAY_SIZE > 0) {
           if (oldCapacity == MAX_ARRAY_SIZE)
               return;
           newCapacity = MAX_ARRAY_SIZE;
       }

       //新建一个size = newCapacity 的HashTable
       Entry<K,V>[] newMap = new Entry[];

       modCount++;
       //重新计算阀值
       threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
       //重新计算hashSeed
       boolean rehash = initHashSeedAsNeeded(newCapacity);

       table = newMap;
       //将原来的元素拷贝到新的HashTable中
       for (int i = oldCapacity ; i-- > 0 ;) {
           for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
               Entry<K,V> e = old;
               old = old.next;

               if (rehash) {
                   e.hash = hash(e.key);
               }
               int index = (e.hash & 0x7FFFFFFF) % newCapacity;
               e.next = newMap[index];
               newMap[index] = e;
           }
       }
   }

3.hash()

计算hash值，由hash值得出key对应的索引

private int hash(Object k) {
    return hashSeed ^ k.hashCode();
}

4.get(Object key)

计算key的hash值，判断在table数组中的索引位置，然后迭代链表，匹配直到找到相对应key的value,若没有找到返回null。

public synchronized V get(Object key) {
     Entry tab[] = table;
     int hash = hash(key);
     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;
 }

四.遍历方式

前置条件：

    Hashtable<String, Object> hashtable = null; 
    @Before 
    public void init(){
        hashtable = new Hashtable<String, Object>();  
        hashtable.put("now", "you");
        hashtable.put("see", "me");
        hashtable.put("cause", "i");
        hashtable.put("let", "be");
    }

1. 遍历Hashtable的键值对

由entrySet()获取Hashtable的“键值对”的Set集合
通过Iterator迭代器遍历Set集合

@Test
public void HashTableTraversalTest1(){
    Iterator<Map.Entry<String, Object>> iterator =  hashtable.entrySet().iterator();
    while (iterator.hasNext()) {
         Map.Entry<String, Object> entry = (Map.Entry<String, Object>)iterator.next();
         System.out.println(entry.getKey()+":"+entry.getValue());
    }
}

结果打印：

see:me
now:you
let:be
cause:i

2.通过Iterator遍历Hashtable的键

(1)获取keys集合方式1

由keySet()获取Hashtable的“键”的Set集合
通过Iterator迭代器遍历Set集合的key
如需要获取value，由key再定位获取到value

@Test
public void HashTableTraversalTest2(){
    Iterator<String> iterator =  hashtable.keySet().iterator();
    while (iterator.hasNext()) {
         String key = iterator.next();
         System.out.println(key+":"+hashtable.get(key));
    }
}

(2)获取keys集合方式2

由hashtable.keys()方法获取keys获取Hashtable的Enumeration集合
通过Iterator迭代器遍历Enumeration集合的值
如需要获取value，由key再定位获取到value

@Test
public void HashTableTraversalTest3(){
    Enumeration<String> enumeration =  hashtable.keys();
    while (enumeration.hasMoreElements()) {
        String string = (String) enumeration.nextElement();          
        System.out.println(string+":"+hashtable.get(string));
    }
}

3.通过Iterator遍历Hashtable的值

(1)获取values集合方式1

由keySet()获取Hashtable的“键”的Collection
通过Iterator迭代器遍历Collection

@Test
public void HashTableTraversalValuesTest4(){
    Collection<Object> c = hashtable.values();
    Iterator<Object> iterator = c.iterator();
    while (iterator.hasNext()) {
        Object object = (Object) iterator.next();
        System.out.println(object);
    }
}

(2)获取values集合方式2

由hashtable.keys()方法获取keys获取Hashtable的Enumeration集合
通过Iterator迭代器遍历Enumeration集合的值
如需要获取value，由key再定位获取到value

4.通过Enumeration遍历Hashtable的键

五.HashMap和Hashtable区别

这里写图片描述

1.继承的父类

两个类的继承体系有些不同。虽然都实现了Map、Cloneable、Serializable三个接口。但是HashMap继承自抽象类AbstractMap，而HashTable继承自抽象类Dictionary。其中Dictionary类是一个已经被废弃的类。

初始化大小

Hashtable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。

2.拥有的方法

HashTable比HashMap多了两个公开方法。一个是elements，这来自于抽象类Dictionary，鉴于该类已经废弃，所以这个方法也就没什么用处了。另一个多出来的方法是contains，这个多出来的方法也没什么用，因为它跟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);
 }

3.线程安全性

Hashtable的方法是同步的，几乎每个方法都做了同步。而HashMap则是非同步的，所以在多线程场合要手动同步HashMap，这个区别就像Vector和ArrayList一样。

java.util.HashTable

public synchronized V get(Object key) {
    Entry tab[] = table;
    int hash = hash(key);
    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;
}

public Set<K> keySet() {
    if (keySet == null)
    //使用了Collections.synchronizedSet进行了同步包装。
        keySet = Collections.synchronizedSet(new KeySet(), this);
    return keySet;
}

4.Null Key 和 Null Value

HashMap是支持null键和null值的，而HashTable在遇到null时，会抛出NullPointerException异常。即Hashtable不允许null值（key和value都不可以），HashMap允许null值（key和value都可以）。

5.遍历方式

两个遍历方式的内部实现上不同。
Hashtable使用Enumeration，HashMap使用Iterator。
Hashtable比HashMap多一个elements方法用于遍历。
哈希值的使用不同，Hashtable直接使用对象的hashCode，而HashMap重新计算hash值，而且用于代替求模。

六.淘汰问题

HashTable已经被淘汰了。新写代码不推荐使用HashTable。

//HashTable的类注释：
If a thread-safe implementation is not needed, it is recommended to use HashMap in place of Hashtable. If a thread-safe highly-concurrent implementation is desired, then it is recommended to use java.util.concurrent.ConcurrentHashMap in place of Hashtable.