Java集合-Hashtable

末蓝、 2022-05-09 11:42 224阅读 0赞

## 介绍 ##

*  和HashMap一样，Hashtable 也是一个散列表，它存储的内容是键值对(key-value)映射。
 *  Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。
 *  Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。此外，Hashtable中的映射不是有序的。

## 总结 ##

*  循环遍历的简写方式，游标从大到小遍历可以实现

public static void main(String[] args) { 
        List<String> list = new ArrayList<>();
        list.add("Lions are the most mighty of all animals in Africa.");
        list.add("Those kids always have so much enthusiasm about studying.");
        list.add("Calligraphy is the art of beautiful handwriting.");
    
        // 加强型for循环
        for (String str : list) { 
            System.out.println(str);
        }
        System.out.println("-------------------------------------------");
        // 简洁遍历方式，游标从大到小遍历 
        for (int i = list.size(); i-- > 0; ) { 
            System.out.println(i);
            System.out.println(list.get(i));
        }
    }

## 源码 ##

### 构造函数 ###

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 synchronized int size() { 
        return count;
    }
    
    public synchronized boolean contains(Object value) { 
        if (value == null) { 
            throw new NullPointerException();
        }
    
        Entry<?,?> tab[] = table;
        // 循环遍历（减少了一步，用了i-- > 0）【游标从大到小遍历时成立】
        for (int i = tab.length ; i-- > 0 ;) { 
            for (Entry<?,?> e = tab[i] ; e != null ; e = e.next) { 
                if (e.value.equals(value)) { 
                    return true;
                }
            }
        }
        return false;
    }

### 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;
           // 循环遍历（减少了一步，用了i-- > 0）
           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;
               }
           }
       }

### putAll函数 ###

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

## containsKey函数 ##

public synchronized boolean containsKey(Object key) { 
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) { 
            if ((e.hash == hash) && e.key.equals(key)) { 
                return true;
            }
        }
        return false;
    }