public Hashtable() 
{
        this(11, 0.75f);
}

Constructs a new, empty hashtable with a default initial capacity (11) and load factor (0.75).

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

Constructs a new, empty hashtable with the specified initial capacity and default load factor (0.75).

Parameters:

initialCapacity - the initial capacity of the hashtable.

Throws:

IllegalArgumentException - if the initial capacity is less than zero.

exception: IllegalArgumentException - if the initial capacity is less than zero.

 public Hashtable(Map<? extends K, ? extends V> t) 
{
        this(Math.max(2*t.size(), 11), 0.75f);
        putAll(t);
}

Constructs a new hashtable with the same mappings as the given Map. The hashtable is created with an initial capacity sufficient to hold the mappings in the given Map and a default load factor (0.75).

Parameters:

t - the map whose mappings are to be placed in this map.

Throws:

NullPointerException - if the specified map is null.

since: 1.2 -

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

Constructs a new, empty hashtable with the specified initial capacity and the specified load factor.

Parameters:

initialCapacity - the initial capacity of the hashtable.

loadFactor - the load factor of the hashtable.

Throws:

IllegalArgumentException - if the initial capacity is less than zero, or if the load factor is nonpositive.

exception: IllegalArgumentException - if the initial capacity is less than zero, or if the load factor is nonpositive.

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

Clears this hashtable so that it contains no keys.

 public synchronized Object clone() 
{
        try {
            Hashtable< K,V > t = (Hashtable< K,V >) super.clone();
            t.table = new Entry[table.length];
            for (int i = table.length ; i--  > 0 ; ) {
                t.table[i] = (table[i] != null)
                    ? (Entry< K,V >) 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();
        }
}

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 boolean contains(Object value) 
{
        if (value == null) {
            throw new NullPointerException();
        }
        Entry tab[] = table;
        for (int i = tab.length ; i--  > 0 ;) {
            for (Entry< K,V > e = tab[i] ; e != null ; e = e.next) {
                if (e.value.equals(value)) {
                    return true;
                }
            }
        }
        return false;
}

Tests if some key maps into the specified value in this hashtable. This operation is more expensive than the containsKey method.

Note that this method is identical in functionality to containsValue , (which is part of the Map interface in the collections framework).

 public synchronized boolean containsKey(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 true;
            }
        }
        return false;
}

Tests if the specified object is a key in this hashtable.

 public boolean containsValue(Object value) 
{
        return contains(value);
}

Returns true if this hashtable maps one or more keys to this value.

Note that this method is identical in functionality to contains (which predates the Map interface).

 public synchronized Enumeration<V> elements() 
{
        return this.< V >getEnumeration(VALUES);
}

Returns an enumeration of the values in this hashtable. Use the Enumeration methods on the returned object to fetch the elements sequentially.

 public Set<K, V> entrySet() 
{
        if (entrySet==null)
            entrySet = Collections.synchronizedSet(new EntrySet(), this);
        return entrySet;
}

Returns a Set view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation, or through the setValue operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.

 public synchronized boolean equals(Object o) 
{
        if (o == this)
            return true;
        if (!(o instanceof Map))
            return false;
        Map< K,V > t = (Map< K,V >) o;
        if (t.size() != size())
            return false;
        try {
            Iterator< Map.Entry< K,V > > i = entrySet().iterator();
            while (i.hasNext()) {
                Map.Entry< K,V > e = i.next();
                K key = e.getKey();
                V value = e.getValue();
                if (value == null) {
                    if (!(t.get(key)==null && t.containsKey(key)))
                        return false;
                } else {
                    if (!value.equals(t.get(key)))
                        return false;
                }
            }
        } catch (ClassCastException unused)   {
            return false;
        } catch (NullPointerException unused) {
            return false;
        }
        return true;
}

Compares the specified Object with this Map for equality, as per the definition in the Map interface.

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

Returns the value to which the specified key is mapped, or {@code null} if this map contains no mapping for the key.

More formally, if this map contains a mapping from a key {@code k} to a value {@code v} such that {@code (key.equals(k))}, then this method returns {@code v}; otherwise it returns {@code null}. (There can be at most one such mapping.)

 public synchronized int hashCode() 
{
        /*
         * This code detects the recursion caused by computing the hash code
         * of a self-referential hash table and prevents the stack overflow
         * that would otherwise result.  This allows certain 1.1-era
         * applets with self-referential hash tables to work.  This code
         * abuses the loadFactor field to do double-duty as a hashCode
         * in progress flag, so as not to worsen the space performance.
         * A negative load factor indicates that hash code computation is
         * in progress.
         */
        int h = 0;
        if (count == 0 || loadFactor <  0)
            return h;  // Returns zero
        loadFactor = -loadFactor;  // Mark hashCode computation in progress
        Entry[] tab = table;
        for (int i = 0; i <  tab.length; i++)
            for (Entry e = tab[i]; e != null; e = e.next)
                h += e.key.hashCode() ^ e.value.hashCode();
        loadFactor = -loadFactor;  // Mark hashCode computation complete
        return h;
}

Returns the hash code value for this Map as per the definition in the Map interface.

 public synchronized boolean isEmpty() 
{
        return count == 0;
}

Tests if this hashtable maps no keys to values.

 public Set<K> keySet() 
{
        if (keySet == null)
            keySet = Collections.synchronizedSet(new KeySet(), this);
        return keySet;
}

Returns a Set view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

 public synchronized Enumeration<K> keys() 
{
        return this.< K >getEnumeration(KEYS);
}

Returns an enumeration of the keys in this hashtable.

 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<  >(hash, key, value, e);
        count++;
        return null;
}

Maps the specified key to the specified value in this hashtable. Neither the key nor the value can be null.

The value can be retrieved by calling the get method with a key that is equal to the original key.

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

Copies all of the mappings from the specified map to this hashtable. These mappings will replace any mappings that this hashtable had for any of the keys currently in the specified map.

 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)(newCapacity * loadFactor);
        table = newMap;
        for (int i = oldCapacity ; i--  > 0 ;) {
            for (Entry< K,V > old = oldMap[i] ; old != null ; ) {
                Entry< K,V > e = old;
                old = old.next;
                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = newMap[index];
                newMap[index] = e;
            }
        }
}

Increases the capacity of and internally reorganizes this hashtable, in order to accommodate and access its entries more efficiently. This method is called automatically when the number of keys in the hashtable exceeds this hashtable's capacity and load factor.

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

Removes the key (and its corresponding value) from this hashtable. This method does nothing if the key is not in the hashtable.

 public synchronized int size() 
{
        return count;
}

Returns the number of keys in this hashtable.

 public synchronized String toString() 
{
        int max = size() - 1;
        if (max == -1)
            return "{}";
        StringBuilder sb = new StringBuilder();
        Iterator< Map.Entry< K,V > > it = entrySet().iterator();
        sb.append('{');
        for (int i = 0; ; i++) {
            Map.Entry< K,V > e = it.next();
            K key = e.getKey();
            V value = e.getValue();
            sb.append(key   == this ? "(this Map)" : key.toString());
            sb.append('=');
            sb.append(value == this ? "(this Map)" : value.toString());
            if (i == max)
                return sb.append('}').toString();
            sb.append(", ");
        }
}

Returns a string representation of this Hashtable object in the form of a set of entries, enclosed in braces and separated by the ASCII characters ", " (comma and space). Each entry is rendered as the key, an equals sign =, and the associated element, where the toString method is used to convert the key and element to strings.

 public Collection<V> values() 
{
        if (values==null)
            values = Collections.synchronizedCollection(new ValueCollection(),
                                                        this);
        return values;
}

Returns a Collection view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Collection.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.