一篇文章带你搞定HashTable

在咱们开讲源码之前,首先需要了解下什么是哈希表?

散列表(Hash table 又称哈希表),是根据关键码值(Key value)而直接进行访问的数据结构.也就是说,它通过把关键码值映射到表中的一个位置来访问记录,以加快查找的速度.这个映射函数就叫做散列函数,存放记录的数组叫做散列表. —— 百度百科

如图:

在Java中HashTable以数组+链表来实现,相对于HashMap来说要简单得多.HashTable不同于HashMap,它内部不允许插入null值,同时它是线程安全的,所有的读写操作都进行了锁保护,但也难以避免的对读写效率产生了较大影响.因此在日常开发中为保证线程安全一般建议使用ConcurrentHashMap.

为啥Java中Hashtable中的t要小写? 这不符合驼峰命名规则啊

大意: Hashtable创建于Java1,而集合的统一命名规范是后来在Java2中建立的,而当时又发布了新集合来代替它,再加上大量Java程序使用Hashtable类,考虑到兼容问题不可能将Hashtable改为HashTable.同时Hashtable已经过时了,不建议在代码中使用.

源码分析

结构图

继承关系

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

Dictionary是JDK1.0里引入的抽象类,用于存储键/值对,作用和Map类似.注意Dictionary类已经过时了,在实际开发中,可以通过实现Map接口来完成存储键值对的功能.

类中属性

    /** 内部维护了一个 Entry 数组 */private transient Entry<?,?>[] table;/** 哈希表里的元素数量 */private transient int count;/** 触发扩容的阈值 */private int threshold;/** 加载因子 默认 0.75 */private float loadFactor;/** 记录 涉及到结构变化的次数(offer/remove/clear等)  */private transient int modCount = 0;/** 版本号 */private static final long serialVersionUID = 1421746759512286392L;

table数组里存的Entry实际上是一个单向链表,哈希表的键值对都是存在table里的.

 private static class Entry<K,V> implements Map.Entry<K,V> {final int hash;final K key;V value;Entry<K,V> next;...}

构造函数

    public Hashtable() { this(11, 0.75f); }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);//初始容量最小为1if (initialCapacity==0) initialCapacity = 1;this.loadFactor = loadFactor;table = new Entry<?,?>[initialCapacity];threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);}

Hashtable的默认容量是11,loadFactor默认加载因子0.75.threshold为
数组容量 * loadFactor.

核心函数

添加函数

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;Entry<K,V> entry = (Entry<K,V>)tab[index];// 如果这个hash和key都已经存在了,就把原来的value替换掉for(; entry != null ; entry = entry.next) {if ((entry.hash == hash) && entry.key.equals(key)) {V old = entry.value;entry.value = value;return old;}}// 真正的添加操作addEntry(hash, key, value, index);return null;
}

put函数通过关键字synchronized保证了线程安全.第一行就表明了Hashtable中value都不能为null.通过hash & 0x7FFFFFFF来规避掉负数,再进行分配位置.如果key经常存在了,则覆盖旧值并返回旧值.核心通过addEntry来添加元素.

    private void addEntry(int hash, K key, V value, int index) {modCount++;Entry<?,?> tab[] = table;// 若当前容量已经大于 阈值 进行rehash扩容if (count >= threshold) {  // threshold = count * loadFlor// Rehash the table if the threshold is exceededrehash();tab = table;hash = key.hashCode();index = (hash & 0x7FFFFFFF) % tab.length;}// Creates the new entry.Entry<K,V> e = (Entry<K,V>) tab[index];// 最新插入的 排在最前面tab[index] = new Entry<>(hash, key, value, e);count++;}

addEntry函数先会判断如果需要扩容 当前数量 >= 阈值,调用rehash进行扩容,否则链表叠加.

    protected void rehash() {int oldCapacity = table.length;Entry<?,?>[] oldMap = table;// 新容量为老容量的一倍+1,int newCapacity = (oldCapacity << 1) + 1;if (newCapacity - MAX_ARRAY_SIZE > 0) {if (oldCapacity == MAX_ARRAY_SIZE)// Keep running with MAX_ARRAY_SIZE bucketsreturn;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函数先会把容量扩大1倍+1,然后创建一个newMap,把oldMap里的元素遍历复制到新的newMap里,这个过程是比较耗时的,同时此操作后数组和链表里元素的位置都会发生改变.

删除函数

    public synchronized V remove(Object key) {Entry<?,?> tab[] = table;int hash = key.hashCode();int index = (hash & 0x7FFFFFFF) % tab.length;Entry<K,V> e = (Entry<K,V>)tab[index];// 遍历链表 e 当前节点, prev 上一个节点  next 下一个节点for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {// 性能优化 先 进行hash 判断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;}

remove函数比较简单,通过key定位在数组中的位置,再遍历链表删除元素.

获取函数

    public synchronized V get(Object key) {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.key.equals(key)) {return (V)e.value;}}return null;}

get函数和remove函数比较类似,都是先通过key定位在数组中的位置,再迭代链表找到元素并直接返回.

迭代器

Hashtable里迭代器使用的是比较老的Enumeration接口,其作用和Iterator类似,只提供了遍历的功能.虽然Enumeration还未被废弃,但现在代码里已经很少使用了.本篇文章就不再讲述了,有兴趣的可以去翻翻代码~

public interface Enumeration<E> {/** 判断是否还有元素  */boolean hasMoreElements();/** 如果还有元素则返回下一个元素,否则抛NoSuchElementException异常   */E nextElement();
}

结语

Hashtable整体是比较简单的,其内部充斥着大量的遍历操作,当数据量大的时候操作会非常耗时,非特殊情况下是用不到的.
一般来说,在日常开发中非并发场景推荐使用HashMap,并发场景下虽然可以用Hashtable,但是更推荐使用ConcurrentHashMap.
ConcurrentHashMap内部虽然也是使用Synchronized,但它是针对单个对象的锁,相比于Hashtable里锁的粒度更细,效率更高.