深入源码剖析 HashSet、HashMap、HashTable

HashTable

HashTable 是什么

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

HashTable 是 Java 中哈希表的一种实现形式，它是 Dictionary 的子类，并且实现了 Map 接口。

注1：

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

注2：

Dictionary 类是一个能将键（key）映射到相应的值（value）的抽象父类，其中键和值都是对象，但在任何一个 Dictionary 对象中，每个键至多与一个值形成映射关系。

注3：

Map 则是定义了具有键值对关系的对象能进行的行为的接口

HashTable 的实现原理

了解了 HashTable 的相关概念之后，我们就该想想：HashTable 的具体实现原理是什么呢？我们不妨先简单看看 HashTable 的源码：

注4：

为了让大家别太头疼，我把注释部分去掉了，想要看注释的可以自己到文档里边看，在下面的讲解中有必要的地方我也会给大家指出

private transient Entry<?,?>[] table;

    private transient int count;

    private int threshold;

    private float loadFactor;

    private transient int modCount = 0;

    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)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    }

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

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

    public Hashtable(Map<? extends K, ? extends V> t) {
        this(Math.max(2*t.size(), 11), 0.75f);
        putAll(t);
    }

从 HashTable 最基本的构造方法和相关属性我们可以注意到：

HashTable 中真正用于存储数据的是一个 Entry 数组

初始化 HashTable 时一定要传入 initialCapacity 和 loadFactor 的值，否则将使用默认值定义两者的大小

那么我们不妨就从这两点入手，研究 HashTable 的内部结构。

Entry 在 HashTable 中起什么作用？

我们不妨直接看 HashTable 的源码：

private static class Entry<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        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;
        }

        @SuppressWarnings("unchecked")
        protected Object clone() {
            return new Entry<>(hash, key, value,
                                  (next==null ? null : (Entry<K,V>) next.clone()));
        }

        // Map.Entry Ops

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

        public V setValue(V value) {
            if (value == null)
                throw new NullPointerException();

            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }

        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 ^ Objects.hashCode(value);
        }

        public String toString() {
            return key.toString()+"="+value.toString();
        }
    }

我不知道大家有没有似曾相识的感觉，反正我第一眼看到 Entry 类内的属性就反应过来了：Entry 其实就是一个链表。也就是说，HashTable 内部是结合数组和列表实现哈希表的，具体构造如图：



注5：

数组+链表实现哈希表采用的是链地址法解决冲突，具体内容可以参考我初学哈希表时的一篇博文：简单的哈希表实现（链地址法解决冲突）

initialCapacity 和 loadFactor 是什么？

从注释来看，initialCapacity 是 HashTable 的初始容量，而 loadFactor 是 HashTable 的装载因子。initialCapacity 的作用倒是好懂，就是表示新创建的 HashTable 的容量嘛。那个 loadFactor 是个什么鬼……别急，这就给你解释：

loadFactor 是 HashTable 用于衡量自身容量的值，例如 HashTable 的初始容量为20，装载因子为0.75，那么当 HashTable 中的键值对数量超过15（20*0.75）之后，HashTable 则会调用 rehash() 方法增大其容量，再将待添加的键值对加入 HashTable。

你觉得我在胡扯？不信看源码！

private void addEntry(int hash, K key, V value, int index) {
        modCount++;

        Entry<?,?> tab[] = table;
        if (count >= threshold) {
            // Rehash the table if the threshold is exceeded
            rehash();

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

        // Creates the new entry.
        @SuppressWarnings("unchecked")
        Entry<K,V> e = (Entry<K,V>) tab[index];
        tab[index] = new Entry<>(hash, key, value, e);
        count++;
    }

在我们调用 addEntry() 方法添加新的键值对时，首先会比较当前键值对的数量与装载上限量，如果超过装载上限则会执行 rehash() 方法。

注6：

threshold 就是装载上限，计算公式为：

java  threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);

@SuppressWarnings("unchecked")
    protected void rehash() {
        int oldCapacity = table.length;
        Entry<?,?>[] oldMap = table;

        // overflow-conscious code
        int newCapacity = (oldCapacity << 1) + 1;
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            if (oldCapacity == MAX_ARRAY_SIZE)
                // Keep running with MAX_ARRAY_SIZE buckets
                return;
            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() 方法中则会进行相应的重哈希和新建 Entry 数组的操作。那么 Entry 数组到底会变大多少呢？答案是增大为当前最大容量的两倍：

int newCapacity = (oldCapacity << 1) + 1;

注意事项

在 HashTable 中，键与值的对象都不能是 null

为了能够成功存储和检索到相应的值，用作键的对象必须实现 hashCode() 和 equals() 方法

HashTable 是线程安全的类，其中的方法都实现了 synchronized 关键字。正如我在 String、StringBuffer、StringBuilder的区别及使用 中提到，当你不需要考虑并发时，重复的加锁解锁会带来效率的问题，此外，HashTable 这种保证线程安全的方法也不好。所以在 StackOverflow 的讨论中大部分人也同意：HashTable 已经是过去的类了，并不提倡大家使用 HashTable。

HashMap

HashMap 是什么

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

HashMap 是 Java 中哈希表的一种实现形式，它是 AbstractMap 的子类，并且实现了 Map 接口。事实上 HashMap 与 HashTable 是很相似的，虽然 HashMap 继承于 AbstractMap 类，但是我们进入AbstractMap 类的代码：

public abstract class AbstractMap<K,V> implements Map<K,V>

AbstractMap 类只是一个实现了 Map 接口的抽象类而已。可能有人就会问了，既然 AbstractMap 类已经实现了 Map 接口，为什么 HashMap 还要实现 Map 接口，这不是多此一举么？非也，这是因为目前尚未确定 HashMap 会不会发生改变，此时 AbstractMap 只是 HashMap 的实现细节，如果有一天决定取消 AbstractMap 与 HashMap 的父子关系，那就需要重新写 HashMap 的代码了，而这又是没有必要的，因为 HashMap 所依赖的抽象逻辑 Map 接口就可以提供。

HashMap 的实现原理

同样的，我们截取 HashMap 最基本的组成：属性和构造方法来开始我们的分析的话会发现，HashMap 的实现原理和 HashTable 几乎一样，都是用 Entry 数组进行存储，链地址法解决哈希表中的冲突。并且使用了 initialCapacity 和 loadFactor。

注意事项

虽说 HashMap 与 HashTable 非常相似，但 HashMap 在细节处还是有改变的：

HashMap 的键和值都允许是 null

HashMap 是线程不安全的，但这意味着在非并发情况下 HashMap 是比 HashTable 更好的选择（效率更高），即便是需要考虑并发的情况，我们只要通过 Collections 类的 synchronizedMap 方法就可以获得线程安全的 HashMap，抑或是通过 ConcurrentHashMap 来实现线程安全。

HashMap 不能保证随着时间的推移，元素的次序不会发生改变

HashMap 的迭代器(Iterator)是 fail-fast 迭代器，而 Hashtable 的 enumerator 迭代器不是 fail-fast 。所以当有其它线程改变了 HashMap 的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的 remove() 方法移除元素则不会抛出ConcurrentModificationExceptio n异常。但这并不是一个一定发生的行为，要看 JVM 。这条同样也是Enumeration和Iterator的区别。

HashSet

HashSet 是什么

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable

HashSet 是 Java 中哈希表的一种实现形式，它是 AbstractSet 的子类，并且实现了 Set 接口。但值得注意的是，HashSet 一般用于进行高性能集运算，而实现 Set 接口使 HashSet 中不会出现重复元素。

HashSet 的实现原理

static final long serialVersionUID = -5024744406713321676L;

    private transient HashMap<E,Object> map;

    private static final Object PRESENT = new Object();

    public HashSet() {
        map = new HashMap<>();
    }

    public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }

    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }

    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }

从源码可以看到，HashSet 的内部实现都依赖于 HashMap，也就是说，HashSet 其实就是为了进行几何运算对 HashMap 进行了封装，其他区别倒是不大。

注意事项

HashSet 在计算成员的哈希值时，直接通过对象进行运算，而 HashMap 则是通过存储对象对应的键进行运算