Hashtable源码理解

Hashtable

Hashtable基本介绍：

1. 存放的元素是键值对形式

2. Hashtable的键与值都不能为null

3. Hashtable的使用方法基本上与hashmap一样

4. Hashtable是线程安全的（synchronized），hashmap是线程不安全的

   //Hashtable的put源码  
   public synchronized V put(K key, V value) {//Hashtable是线程安全的（synchronized）
           // Make sure the value is not null
           if (value == null) {//Hashtable的键与值都不能为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<K,V> entry = (Entry<K,V>)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;
       }
   

Hashtable扩容机制

• 当count大于等于临界值8时就会触发扩容

• 扩容时相当于原来的容量翻倍，再加一

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();//当count大于等于临界值8时就会触发扩容

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

//rehash源码
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;
        }
    }
}