HashTable解析

HashTable本身和hashMap差距不大，看了几个hashTable的内部方法实现，发现内部方法没有上锁，但是用public修饰的方法全部用synchronize加上了方法锁，这样是极其消耗性能的，好，我们来看几个内部方法的实现。

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 buckets
                return;
            newCapacity = MAX_ARRAY_SIZE;
        }
        //新数组
        Entry[] newMap = new Entry[newCapacity];

        modCount++;
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        table = newMap;


        //这个地方有点意思，跟hashMap和ConcurrentHashmap的实现不一样
        //前两者是使用hash值与旧数组长度进行与操作，然后分成两条链，直接放到相应位置
        //而hashTable是从前面插入，也就是每插入一个节点，就将这个节点的next指向原有的首节点
        //然后插入节点充当当前位置的首节点
        for (int i = oldCapacity ; i-- > 0 ;) {
            for (Entry old = (Entry)oldMap[i] ; old != null ; ) {
                Entry e = old;
                old = old.next;

                //这个地方有点疑问
                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = (Entry)newMap[index];
                newMap[index] = e;
            }
        }
    }   

在数据迁移过程中，我们可以看到hashTable是通过取余来获取位置的，这个效率肯定不如hashmap，还有一个地方是hash和0x7fffffff进行了与操作，这个三个集合都有点不同，hashmap是先将hash值无符号右移16位然后再跟自身进行异或操作，这个是为了减少hash冲突，但是在ConcurrentHashmap中，它的hash值计算在这个基础上还跟0x7fffffff进行了与操作，而hashtable没有高16和低16位的异或操作，直接跟0x7fffffff进行与操作。
总结一下：
1、hashmap跟hashtable和ConcurrentHashmap的区别在于，后两者都是线程安全的集合，然后他们都跟0x7fffffff进行了与操作
2、hashTable的位置计算直接通过取余的方式，在位置选择上的性能上会低于hashmap和concurrentHashmap
3、ConcurrentHashmap中有个数据迁移的地方比较高明，在分成两条链进行插入的时候，它要对原有的链进行遍历，在遍历的过程中发现可以重用的节点，然后不用再二次创建这些节点，在使用中可能会大大提高性能够，因为这个类是处理高并发的集合。

addEntry

    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 e = (Entry) tab[index];
        //插入节点，也是一样从链表头插入
        tab[index] = new Entry<>(hash, key, value, e);
        count++;
    }

这个方法也比较简单，跟前面的rehash一样，插入新节点是从链表头插入的

put

    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;
        @SuppressWarnings("unchecked")
        Entry entry = (Entry)tab[index];
        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;
    }   

这个方法之所以拿出来讲，我们看第一条判断语句，value==null的判断，也就是说hashtable不支持value为空，但是支持key为空，hashmap既支持key也支持value为空，而ConcurrentHashMap是都不支持二者为空的情况，这个也是三个集合类的区别之一。
为什么要这样规定key或者value不能为空呢？（网上感觉比较合理的解释如下）
ConcurrentHashmap和Hashtable都是支持并发的，这样会有一个问题，当你通过get(k)获取对应的value时，如果获取到的是null时，你无法判断，它是put（k,v）的时候value为null，还是这个key从来没有做过映射。HashMap是非并发的，可以通过contains(key)来做这个判断。而支持并发的Map在调用m.contains（key）和m.get(key),m可能已经不同了。

clone

  //Creates a shallow copy of this hashtable. All the structure of the
// hashtable itself is copied, but the keys and values are not cloned.
  //This is a relatively expensive operation
    public synchronized Object clone() {
        try {
            Hashtable t = (Hashtable)super.clone();
            t.table = new Entry[table.length];
            for (int i = table.length ; i-- > 0 ; ) {
                t.table[i] = (table[i] != null)
                    ? (Entry) table[i].clone() : null;
            }
            t.keySet = null;
            t.entrySet = null;
            t.values = null;
            t.modCount = 0;
            return t;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }   

看到方法上的注释可以知道这个类跟hashmap一样都是浅拷贝的，key和value值不拷贝，而相比于此，ConcurrentHashMap是没有提供拷贝方法的，也就是不能进行拷贝。