HashMap和Hashtable 之源代码详解

 

HashMap和Hashtable 之源代码详解

 

Hashtable从JDK1.0就已经有了, 所以让我们先来看看它是怎么工作, 然后有浅入深, 来研究HashMap的原理, 以及两者的不同点.

 

Hashtable有几个主要的字段, 如下,

 

    /**
     * The hash table data.
     */
    private transient Entry[] table;

    /**
     * The total number of entries in the hash table.
     */
    private transient int count;

    /**
     * The table is rehashed when its size exceeds this threshold. (The
     * value of this field is (int)(capacity * loadFactor).)
     *
     * @serial
     */
    private int threshold;

 

其中最重要的就是那个table数组了. 它就是整个hashtable的基本数据结构! 在来看一下这个字段

private transient Entry[] table;

 

可以看到, hashtable的基本数据结构就是, 一个包涵Entry类的二维数组. 而这个Entry类是hashtable的内在类, 它其实是一个单向链, 让我们详细分析一下.

 

 

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

...

 

看到这里有没有想到学校里教的数据结构原理这门课呢? Entry类就是定义了一个很简单的单向链结构, 它里面包括key, value和下个Entry类的对象next.

在这里我在强调一下, hashtable 的数据结构就是一个包涵单向链的二维数组.

 

 

 

 

接下来让我们来看看hashtable的构造器是长的什么样的.

 

最长用的

 

    public Hashtable() {
            this(11, 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 = new Entry[initialCapacity];
            threshold = (int)(initialCapacity * loadFactor);
    }

 

细读代码后, 我们发现这个构造器构造了table字段和threshold. Table前面已经详细讲了, 那么这个threshold又是什么东东呢?

其实这个threshold对hashtalbe的性能影响是很大的! 因为table是个数组, 如果在hashtable中保存的实体大于一定的数量后, 对数据的读写就会有很慢, 那是因为, 很多数据都保存在entry类的单向链中, 每次读写都要比对链中所有的数据, 链越长读写就越慢.

所以当数据容量大于threshold的时候, hashtable就会做rehash(), rehash把table的容量扩大一倍, 再把从前在table里的数据统统搬回新的table. 这样的一个过程, 开销是多么的大呀.

threshold = (int)(initialCapacity * loadFactor);

Hashtable类提供了构造涵数, 用户可以自定, intitialCapacity和loadFactor. 对于那些大概知道容量的hashtable, 用户应该自定intitialCapacity. 这样的话, 就可以省去一大笔rehash的开销.

 

现在让我们来看hashtable的put和get操作

 

 

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

 

先来看get方法, get可谓是hashtable中的最基本方法了, 它是通过key来拿到hashtable中的value.

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

从key拿到hashCode, 从hashCode再计算出在table中的index, 也就是在数组中的第几个列.

至于为什么要与 0x7FFFFFFF, 那是hashtable 提供的hash算法, hashMap提供了不同的算法, 用户如果要定义自己的算法也是可以的. 如果要知道不同的具体算法, 就google or 百度一下吧.

 

好了, 现在我们有了index, 就可以到table数组里的entry单向链去找value啦.

 

for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
                if ((e.hash == hash) && e.key.equals(key)) {
                        return e.value;
                }
            }

 

for语句就是简单的检索entry的单链, if语句检查key是否相同. 这里就遇到了java学习中的一个重大知识点. hasCode()和equal()的关系.

大家都学过如果hasCode()的值相同的话, equal不一定相同, 而如果equal相同的话, hasCode一定要相同. 但那是为什么呢? 其实答案就在上面的代码中!

Hashtable的数据结构是 一个包涵单向链的二维数组. 从hasCode我们得到hash和index, 并得以确定这个key在table数组中的第几个列, 然而这显然是不够的, 因为, entry类是一个单向列, 它可以是一个, 也可能是很多个key组成, 那么要从一系列有着相同hasCode的entry中找到, 我们所要的key的话, 就要用equals了. 只有两个key是相等的, 那才是我们要找的. 找到key之后, 只要简单的把value返回就好了. 如果对entry类还有疑问的话, 请参考前面的解释.

 

 

 

   public synchronized V put(K key, V value) {
            // Make sure the value is not null
            if (value == null) {
                throw new NullPointerException();
            }

            // Makes sure the key is not already in the hashtable.
            Entry tab[] = table;
            int hash = key.hashCode();
            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)) {
                        V old = e.value;
                        e.value = value;
                        return old;
                }
            }

            modCount++;
            if (count >= threshold) {
                // Rehash the table if the threshold is exceeded
                rehash();

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

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

 

接下来再来看看put方法, 理解了get, put就很容易弄明白了.

首先, 要放入hashtable的value不能是null, 否则就报错.

其次, 然后要确保key不能已经在hashtable里面, 有的话, 就返回value.

再次, 检查是否容量已经太大, 如果太大话就rehash, 这会是一个很浪费资源的方法, 请参考前文.

 

 最后, 也是最重要的, 我们要把key-value保存到hashtable中去.

 

            Entry<K,V> e = tab[index];
            tab[index] = new Entry<K,V>(hash, key, value, e);

1. 拿到当前在table数组中的entry对象.
2. 根据传入的key和value建一个新的entry并赋予给当前的table的index中

            protected Entry(int hash, K key, V value, Entry<K,V> next) {
                this.hash = hash;
                this.key = key;
                this.value = value;
                this.next = next;
            }

            这是entry类的构造函数. 简单的说, 就是在单链的最前端加了个新的entry对象. 从这里也可以看出, 对于那些后写入的object, 反而可以以比较快的速度读出, 那是因为后写入的object, 总是在链的前端.

 

 

看完了hashtable, 我们在来看看hashMap

hashMap可以算作是hashtable的升级版本, 最早从1.2开始有的.

整体上hashMap对hashtable类优化了代码. 比如说, 消除了hardcoding, 增加了code reuse等等.

但是, 两者之间最主要的不同有两点.

1.     hashMap的读写是unsynchronized, 在多线程的环境中要注意使用

而hashtable是synchronized

这两者的不同是通过在读写方法上加synchronized关键字来实现的.

 

hashMap

public V put(K key, V value)

public V get(Object key)

 

hashtable

public synchronized V get(Object key)

public synchronized V put(K key, V value)

 

可能有人问, 能synchronized, 能线程安全好啊. 为什么不要呢?

这里其实还是一个效率的问题. 对于线程安全的方法, 系统要进行加锁, 减锁操作. 性能会有很大的影响. 由于很多程序是在单线程或者说是线程安全的情况下工作的, 所以用synchronized就显得多余了.

 

3. 第二个不同是hashMap可以放空值, 而hashtable就会报错.

hashMap

public V put(K key, V value) {

            if (key == null)

                return putForNullKey(value);

 

hashtable

public synchronized V put(K key, V value) {

            // Make sure the value is not null

            if (value == null) {

                throw new NullPointerException();

            }