HashTable源码

一直写一些工作日常笔记，最近想静下来看下一些常见的知识原理，在很多blog上都有看到过，不过看到的东西是别人的，只有自己去看了源码，写了demo，理解了才是自己的东西。

hashTable（jdk1.7）

定义：
继承与Dictionary，实现了Map的一些方法，标记了这个对象Clone，以及序列化Serializable

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

构造器及初始化：
不传任何参数的构造器，系统默认容量为11，hash因子0.75

new Hashtable（）;//this(11, 0.75f);

传入容量大小的initialCapacity，

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

传入容量（initialCapacity）和hash因子（loadFactor）

 new Hashtable(int initialCapacity, float loadFactor) 

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);
        //容量为0，设置一个容量为，保证传入不是IsEmpty
        if (initialCapacity==0)
            initialCapacity = 1;
        this.loadFactor = loadFactor;
        //创建一个Entry数组，Entry是一个单链表结构
        table = new Entry[initialCapacity];
        //设置一个阀值threshold=容量*hash因子，超过这个阀值，需要对数组扩容
        threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        initHashSeedAsNeeded(initialCapacity);
}

构造其中主要是初始化容量值，hash因子，threshold，创建一个单链表对象数组。还看到一个initHashSeedAsNeeded方法，这个方法主要初始化hashSeed参数，其中hashSeed用于计算key的hash值，它与key的hashCode进行按位异或运算。这个hashSeed是一个与实例相关的随机值，主要用于解决hash冲突。

重要方法：

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;
        //使用hashSend与运算key.hashCode
        int hash = hash(key);
        //hash & 0x7FFFFFFF防止hash为负值吧 
        //这里使用除法散列
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
        //遇到hash值相同的插入，使用单链表连接起来，解决hash冲突
            if ((e.hash == hash) && e.key.equals(key)) {
                V old = e.value;
                e.value = value;
                return old;
            }
        }
       //modCount没修改一次计数加1，与添加数量无关，用于遍历时候检查操作合法性
        modCount++;
        if (count >= threshold) {
            // Rehash the table if the threshold is exceeded
            //重hash 数组中元素超过阀值，需要再次计算容量，扩容数组
            rehash();

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

        // Creates the new entry.每次扩容创建新数组，开销比较大，所以给定好初始容量比较重要，减少数组扩容
        Entry<K,V> e = tab[index];
        tab[index] = new Entry<>(hash, key, value, e);
        count++;
        return null;
    }

put方法比较简单，就是先对key值hash然后与hashSend这个随机值与运行，这样做的好处是减少hash重复。然后使用除法散列法，把对象放入到entry数组，如果遇到hash值重复，使用单链表把相同hash值的元素连接起来。但数组达到阀值（threshold），对创建一个新数组进行扩容。
接下来看下rehash

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

        // overflow-conscious code
        //计算新数组容量，左移1位，new=2*old+1
        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<K,V>[] newMap = new Entry[newCapacity];

        modCount++;
        //重新生成阀值
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        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;
            }
        }
    }

接下看看putAll，这个方法没什么说的，遍历传入集合，最终还是调用put方法

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

get方法 先hash转入key，然后找到对应的index，在entry数组中找到对应的entry对象，再通过hash值和key比较找到想要的对象值返回

    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) {
            //hash重复，判断key是否同一个对象
            if ((e.hash == hash) && e.key.equals(key)) {
                return e.value;
            }
        }
        return null;
    }

看完获取，添加元素后，再来看看删除
同样先hash转入key，然后找到对应的index，在entry数组中找到对应的entry对象，再通过hash值和key比较找到想要的对象，如果当前entry没有prev，直接把该对象的next指向tab[index],断开该对象的链表；

如果该对象有prev，和next就把该对象的prev.next指向该对象的next

    public synchronized V remove(Object key) {
        Entry tab[] = table;
        int hash = hash(key);
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<K,V> e = tab[index], prev = null ; e != null ; prev = e, e = e.next) {
            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;
    }

clear没什么可说的 把所有的元素置null

   public synchronized void clear() {
        Entry tab[] = table;
        modCount++;
        for (int index = tab.length; --index >= 0; )
            tab[index] = null;
        count = 0;
    }

迭代器Enumeration：
hashTable使用的是Enumeration迭代器接口
　Enumeration接口是JDK1.0时推出的，最早使用Vector时就是使用Enumeration接口进行输出。虽然Enumeration是一个旧的类，但是在JDK1.5之后为Enumeration类进行了扩充，增加了泛型的操作应用。

　Enumeration接口常用的方法有hasMoreElements()（判断是否有下一个值）和 nextElement()（取出当前元素），这些方法的功能跟Iterator类似，只是Iterator中存在删除数据的方法，而此接口不存在删除操作。

HashTable与HashMap的区别

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

第二：HashMap可以允许存在一个为null的key和任意个为null的value，但是HashTable中的key和value都不允许为null。
第三：迭代器不同，hashTable使用的比较古老的Enumeration，而hashMap使用的是Interator
第四：Hashtable的方法是同步的，而HashMap的方法不是。所以有人一般都建议如果是涉及到多线程同步时采用HashTable，没有涉及就采用HashMap，