null object
* can be used as a key or as a value.
*
*
* To successfully store and retrieve objects from a hashtable, the objects used as keys must
* implement the hashCode method and the equals method.
*
*
* An instance of Hashtable has two parameters that affect its performance: initial
* capacity and load factor. The capacity is the number of buckets in the
* hash table, and the initial capacity is simply the capacity at the time the hash table is
* created. Note that the hash table is open: in the case of a "hash collision", a single
* bucket stores multiple entries, which must be searched sequentially. The load factor is a
* measure of how full the hash table is allowed to get before its capacity is automatically
* increased. The initial capacity and load factor parameters are merely hints to the
* implementation. The exact details as to when and whether the rehash method is invoked are
* implementation-dependent.
*
*
* Generally, the default load factor (.75) offers a good tradeoff between time and space costs.
* Higher values decrease the space overhead but increase the time cost to look up an entry (which
* is reflected in most Hashtable operations, including get and put).
*
*
* The initial capacity controls a tradeoff between wasted space and the need for
* rehash operations, which are time-consuming. No rehash operations will
* ever occur if the initial capacity is greater than the maximum number of entries the
* Hashtable will contain divided by its load factor. However, setting the initial capacity
* too high can waste space.
*
*
* If many entries are to be made into a Hashtable, creating it with a sufficiently
* large capacity may allow the entries to be inserted more efficiently than letting it perform
* automatic rehashing as needed to grow the table.
*
* * This example creates a hashtable of numbers. It uses the names of the numbers as keys: * *
* {
* @code
* Hashtable<String, Integer> numbers = new Hashtable<String, Integer>();
* numbers.put("one", 1);
* numbers.put("two", 2);
* numbers.put("three", 3);
* }
*
*
* * To retrieve a number, use the following code: * *
* {
* @code
* Integer n = numbers.get("two");
* if (n != null) {
* System.out.println("two = " + n);
* }
* }
*
*
*
* The iterators returned by the iterator method of the collections returned by all of this
* class's "collection view methods" are fail-fast: if the Hashtable is structurally
* modified at any time after the iterator is created, in any way except through the iterator's own
* remove method, the iterator will throw a {@link ConcurrentModificationException}. Thus,
* in the face of concurrent modification, the iterator fails quickly and cleanly, rather than
* risking arbitrary, non-deterministic behavior at an undetermined time in the future. The
* Enumerations returned by Hashtable's keys and elements methods are not fail-fast.
*
*
* Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally
* speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent
* modification. Fail-fast iterators throw
* Note that this method is identical in functionality to {@link #containsValue containsValue},
* (which is part of the {@link Map} interface in the collections framework).
*
* @param value
* a value to search for
* @return
* Note that this method is identical in functionality to {@link #contains contains} (which predates
* the {@link Map} interface).
*
* @param value
* value whose presence in this hashtable is to be tested
* @return
* 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.)
*
* @param key
* the key whose associated value is to be returned
* @return the value to which the specified key is mapped, or {@code null} if this map contains no
* mapping for the key
* @throws NullPointerException
* if the specified key is null
* @see #put(Object, Object)
*/
@Override
@Nullable
public V get(Object key) {
throw new RuntimeException();
}
/**
* Returns the hash code value for this Map as per the definition in the Map interface.
*
* @see Map#hashCode()
*/
@Override
public int hashCode() {
throw new RuntimeException();
}
/**
* Tests if this hashtable maps no keys to values.
*
* @return
*
* The value can be retrieved by calling the ConcurrentModificationException on a best-effort
* basis. Therefore, it would be wrong to write a program that depended on this exception for its
* correctness: the fail-fast behavior of iterators should be used only to detect bugs.
*
* @param true if and only if some key maps to the value argument in this
* hashtable as determined by the equals method; false otherwise.
* @exception NullPointerException
* if the value is null
*/
public boolean contains(Object value) {
throw new RuntimeException();
}
/**
* Tests if the specified object is a key in this hashtable.
*
* @param key
* possible key
* @return true if and only if the specified object is a key in this hashtable, as
* determined by the equals method; false otherwise.
* @throws NullPointerException
* if the key is null
* @see #contains(Object)
*/
@Override
public boolean containsKey(Object key) {
throw new RuntimeException();
}
/**
* Returns true if this hashtable maps one or more keys to this value.
*
* true if this map maps one or more keys to the specified value
* @throws NullPointerException
* if the value is null
*/
@Override
public boolean containsValue(Object value) {
throw new RuntimeException();
}
/**
* Returns an enumeration of the values in this hashtable. Use the Enumeration methods on the
* returned object to fetch the elements sequentially.
*
* @return an enumeration of the values in this hashtable.
* @see java.util.Enumeration
* @see #keys()
* @see #values()
* @see Map
*/
@Override
public Enumerationremove
* 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.
*/
@Override
public Settrue if this hashtable maps no keys to values; false otherwise.
*/
@Override
public boolean isEmpty() {
throw new RuntimeException();
}
/**
* Returns an enumeration of the keys in this hashtable.
*
* @return an enumeration of the keys in this hashtable.
* @see Enumeration
* @see #elements()
* @see #keySet()
* @see Map
*/
@Override
public Enumerationremove
* 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.
*/
@Override
public Setkey to the specified value in this hashtable.
* Neither the key nor the value can be null.
* get method with a key that is equal to the
* original key.
*
* @param key
* the hashtable key
* @param value
* the value
* @return the previous value of the specified key in this hashtable, or null if it did
* not have one
* @exception NullPointerException
* if the key or value is null
* @see Object#equals(Object)
* @see #get(Object)
*/
@Override
@Nullable
public V put(K key, V value) {
throw new RuntimeException();
}
/**
* 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.
*
* @param t
* mappings to be stored in this map
* @throws NullPointerException
* if the specified map is null
*/
@Override
public void putAll(Map t) {
throw new RuntimeException();
}
/**
* 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.
*/
protected void rehash() {
throw new RuntimeException();
}
/**
* Removes the key (and its corresponding value) from this hashtable. This method does nothing if
* the key is not in the hashtable.
*
* @param key
* the key that needs to be removed
* @return the value to which the key had been mapped in this hashtable, or null if the
* key did not have a mapping
* @throws NullPointerException
* if the key is null
*/
@Override
@Nullable
public V remove(Object key) {
throw new RuntimeException();
}
/**
* Returns the number of keys in this hashtable.
*
* @return the number of keys in this hashtable.
*/
@Override
public int size() {
throw new RuntimeException();
}
/**
* 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.
*
* @return a string representation of this hashtable
*/
@Override
public String toString() {
throw new RuntimeException();
}
/**
* Returns a {@link 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.
*/
@Override
public Collection