深入Java集合系列之七：Hashtable

最新推荐文章于 2022-05-05 18:52:44 发布

点滴~

最新推荐文章于 2022-05-05 18:52:44 发布

阅读量288

点赞数

分类专栏：集合框架文章标签： HashTable Java集合框架

本文链接：https://blog.youkuaiyun.com/oqkdws/article/details/79954191

版权

集合框架专栏收录该内容

26 篇文章

订阅专栏

之前一直是看别人对于其他几个集合框架的分析，现在自己也来分析一下Hashtable的源码以及用法。

首先，为了提高兴趣，我们先来看看这个源码是谁写的。

* @author  Arthur van Hoff
 * @author  Josh Bloch
 * @author  Neal Gafter
 * @see     Object#equals(java.lang.Object)
 * @see     Object#hashCode()
 * @see     Hashtable#rehash()
 * @see     Collection
 * @see     Map
 * @see     HashMap
 * @see     TreeMap
 * @since JDK1.0

看这个我们知道作者有Arthur van Hoff，Josh Bloch，Neal Gafter。

我们先来看看这几个人的简介：

（1）Arthur van Hoff

Arthur van Hoff先生是一位连续创业的企业家。在创立Jaunt之前，他曾任Flipboard公司首席技术官。Arthur van Hoff先生最早任职于硅谷的Sun Microsystems公司，从事Java程序语言的早期开发工作。随后创立了多家成功的企业，其中包括Marimba（1999年IPO）、Strangeberry（后被TiVo收购）、ZING（后被Dell收购）和Ellerdale（后被Flipboard收购）。
 
Arthur van Hoff 先生对机器学习、大数据、移动应用、3D 打印和计算摄影等领域有深入研究。他来自荷兰，持有格拉斯高斯特拉思克莱德大学（Strathclyde University）计算机科学硕士学位。

（2）Josh Bloch

Java 集合框架创办人，Joshua Bloch 领导了很多 Java 平台特性的设计和实现，包括 JDK 5.0 语言增强以及屡获殊荣的 Java 集合框架。2004年6月他离开了SUN公司并成为 Google 的首席 Java 架构师。此外他还因为《Effective Java》一书获得著名的 Jolt 大奖。

哥伦比亚大学计算机科学专业学士学位
卡内基梅隆大学计算机科学专业博士学位

（3）Neal Gafter

Sun的Java编程语言编译器和相关工具（javac，javadoc，javah，javap）的主要设计者和开发人员，通过JDK 1.5从J2SE 1.3.1发布。为Java 1.4.0（Merlin）和1.5.0（Tiger）设计或共同设计了新的语言特性和库支持。实施新的语言功能。改造了核心库（java.lang，java.util，java.lang.reflect等）以利用新的语言特性。在1.4.2中将javac bug计数归零。

罗切斯特大学 计算机科学博士

看到没有，都是高学历、很厉害的人写的东西，难道不比大部分平庸的码农写的好，我们是不是应该好好学习一下呢？想吃这碗饭的话。

来我们开始吧！

定义

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

从代码可以看出，Hashtable继承了Dictionary抽象类，实现了Map接口。

private transient Entry<?,?>[] table; //为一个Entry[]数组类型，Entry代表了“拉链”的节点，每一个Entry代表了一个键值对，哈希表的"key-value键值对"都是存储在Entry数组中的。


private transient int count;//HashTable的大小，注意这个大小并不是HashTable的容器大小，而是他所包含Entry键值对的数量。


    private int threshold; //Hashtable的阈值，用于判断是否需要调整Hashtable的容量。threshold的值="容量*加载因子"。


    private float loadFactor; //加载因子。


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

构造方法

在HashTabel中存在5个构造函数。通过这5个构造函数我们构建出一个我想要的HashTable。

 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];      //定义Entry<?,?>类型的数组容量
        threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);//数组最大容量和负载因子的乘积和虚拟机最大容量取最小值
    }
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//虚拟机最大容量减8

public Hashtable() {
        this(11, 0.75f); //默认负载因子0.75，初始容量11
    }

public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);  //可以定义数组容量
    }

 public Hashtable(Map<? extends K, ? extends V> t) {
        this(Math.max(2*t.size(), 11), 0.75f);  //设置容量为Math.max(2*t.size(), 11)
        putAll(t); 设置和已定义Map一样的哈希关系
    }

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()); //报已经有的map哈希表都存到这个新的Hashtable的Entry<?,?>类型的数组里面，实现创建一个一样哈希映射的表

主要方法

（1）put方法

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 = key.hashCode(); //计算key的hash值
        int index = (hash & 0x7FFFFFFF) % tab.length;  //确认该key的索引位置
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];  //定义一个Entry<K,V>类型的结点
        for(; entry != null ; entry = entry.next) { //迭代，寻找该key，替换
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }

        addEntry(hash, key, value, index);
        return null;
    }

private void addEntry(int hash, K key, V value, int index) {
        modCount++; //修改数据的次数

        Entry<?,?> tab[] = table; 
        if (count >= threshold) {
            //如果容器中的元素数量已经达到阀值，则进行扩容操作
            rehash();

            tab = table;
            hash = key.hashCode();
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

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

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

首先我们假设一个容量为5的table，存在8、10、13、16、17、21。他们在table中位置如下：

然后我们插入一个数：put(16,22)，key=16在table的索引位置为1，同时在1索引位置有两个数，程序对该“链表”进行迭代，发现存在一个key=16,这时要做的工作就是用newValue=22替换oldValue16，并将oldValue=16返回。

在put(33,33)，key=33所在的索引位置为3，并且在该链表中也没有存在某个key=33的节点，所以就将该节点插入该链表的第一个位置。（注：图是转的，有点错误，改了33）

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

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

        //新容量=旧容量 * 2 + 1
        int newCapacity = (oldCapacity << 1) + 1;
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            if (oldCapacity == MAX_ARRAY_SIZE)
                //保持容量为MAX_ARRAY_SIZE
                return;
            newCapacity = MAX_ARRAY_SIZE;
        }
        //新建一个size = newCapacity 的HashTable
        Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];

        modCount++;//修改次数加一
        //重新计算阀值
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        table = newMap;
        //将原来的元素拷贝到新的HashTable中
        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，同时需要将原来HashTable中的元素一一复制到新的HashTable中，这个过程是比较消耗时间的，同时还需要根据新的hash值（hash = key.hashCode()，这个hashCode（）方法是调用其他语言的方法得到的值）计算出index，毕竟容量已经变了。这里对阀值啰嗦一下：比如初始值11、加载因子默认0.75，那么这个时候阀值threshold=8，当容器中的元素达到8时，HashTable进行一次扩容操作，容量 = 8 * 2 + 1 =17，而阀值threshold=17*0.75 = 13，当容器元素再一次达到阀值时，HashTable还会进行扩容操作，依此类推。

（2）get方法

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

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;
    }

Hashtable和HashMap的区别

HashTable和HashMap存在很多的相同点，但是他们还是有几个比较重要的不同点。

第一：我们从他们的定义就可以看出他们的不同，HashTable基于Dictionary类，而HashMap是基于AbstractMap。Dictionary是什么？它是任何可将键映射到相应值的类的抽象父类，而AbstractMap是基于Map接口的骨干实现，它以最大限度地减少实现此接口所需的工作。

第二：HashMap可以允许存在一个为null的key和任意个为null的value，但是HashTable中的key和value都不允许为null。如下：

当HashMap遇到为null的key时，它会调用putForNullKey方法来进行处理。对于value没有进行任何处理，只要是对象都可以。

代码略。。。

而当HashTable遇到null时，他会直接抛出NullPointerException异常信息。

 if (value == null) {
            throw new NullPointerException();
        }

第三： Hashtable的方法是同步的，而HashMap的方法不是。所以有人一般都建议如果是涉及到多线程同步时采用HashTable，没有涉及就采用HashMap，但是在Collections类中存在一个静态方法：synchronizedMap()，该方法创建了一个线程安全的Map对象，并把它作为一个封装的对象来返回，所以通过Collections类的synchronizedMap方法是可以我们你同步访问潜在的HashMap。