Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## java.util
Class Hashtable<K,V>

    java.lang.Object
      java.util.Hashtable<K,V>

    @TransactionType(value=SUPPORTS)
    public class Hashtable<K,V>

extends Object

This class implements a hashtable, which maps keys to values. Any non-`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 efficiency: its capacity and its load factor. The load factor in the CLDC implementation of the hashtable class is always 75 percent. When the number of entries in the hashtable exceeds the product of the load factor and the current capacity, the capacity is increased by calling the `rehash` method.

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:

>      Hashtable numbers = new Hashtable();
>      numbers.put("one", new Integer(1));
>      numbers.put("two", new Integer(2));
>      numbers.put("three", new Integer(3));

To retrieve a number, use the following code:

>      Integer n = (Integer) numbers.get("two");
>      if (n != null) {
>          System.out.println("two = " + n);
>      }

This class is thread-safe (synchronzied).

Since:
  JDK1.0, CLDC 1.0, Java Card 3.0
See Also:
  `Object.equals(java.lang.Object)`, `Object.hashCode()`, `rehash()`

Constructor Summary
`Hashtable()` Constructs a new, empty hashtable with a default initial capacity (11) and load factor (0.75).
`Hashtable(int initialCapacity)` Constructs a new, empty hashtable with the specified initial capacity and default load factor (0.75).

Method Summary
`void` | `clear()` Clears this hashtable so that it contains no keys.
`boolean` | `contains(Object value)` Tests if some key maps into the specified value in this hashtable.
`boolean` | `containsKey(Object key)` Tests if the specified object is a key in this hashtable.
`Enumeration<V>` | `elements()` Returns an enumeration of the values in this hashtable.
`boolean` | `equals(Object o)` Compares the specified object with this hashtable for equality.
`V` | `get(K key)` Returns the value to which the specified key is mapped in this hashtable.
`int` | `hashCode()` Returns the hash code value for this hashtable.
`boolean` | `isEmpty()` Tests if this hashtable maps no keys to values.
`Enumeration<K>` | `keys()` Returns an enumeration of the keys in this hashtable.
`V` | `put(K key, V value)` Maps the specified `key` to the specified `value` in this hashtable.
`protected void` | `rehash()` Rehashes the contents of the hashtable into a hashtable with a larger capacity.
`V` | `remove(K key)` Removes the key (and its corresponding value) from this hashtable.
`int` | `size()` Returns the number of keys in this hashtable.
`String` | `toString()` Returns a rather long string representation of this hashtable.

Methods inherited from class java.lang.Object
`getClass, notify, notifyAll, wait, wait, wait`

Constructor Detail

### Hashtable

    public Hashtable(int initialCapacity)

  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
  Since:
    JDK1.0

### Hashtable

    public Hashtable()

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

  Since:
    JDK1.0

Method Detail

### size

    public int size()

  Returns the number of keys in this hashtable.

  Returns:
    the number of keys in this hashtable.
  Since:
    JDK1.0

### isEmpty

    public boolean isEmpty()

  Tests if this hashtable maps no keys to values.

  Returns:
    `true` if this hashtable maps no keys to values; `false` otherwise.
  Since:
    JDK1.0

### keys

    public Enumeration<K> keys()

  Returns an enumeration of the keys in this hashtable.

  Returns:
    an enumeration of the keys in this hashtable.
  Since:
    JDK1.0
  See Also:
    `Enumeration`, `elements()`

### elements

    public Enumeration<V> elements()

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

  Returns:
    an enumeration of the values in this hashtable.
  Since:
    JDK1.0
  See Also:
    `Enumeration`, `keys()`

### contains

    public boolean contains(Object value)

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

  Parameters:
    `value` - a value to search for.
  Returns:
    `true` if some key maps to the `value` argument in this hashtable; `false` otherwise.
  Throws:
    `NullPointerException` - if the value is `null`.
  Since:
    JDK1.0
  See Also:
    `containsKey(java.lang.Object)`

### containsKey

    public boolean containsKey(Object key)

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

  Parameters:
    `key` - possible key.
  Returns:
    `true` if the specified object is a key in this hashtable; `false` otherwise.
  Since:
    JDK1.0
  See Also:
    `contains(java.lang.Object)`

### get

    public V get(K key)

  Returns the value to which the specified key is mapped in this hashtable.

  Parameters:
    `key` - a key in the hashtable.
  Returns:
    the value to which the key is mapped in this hashtable; `null` if the key is not mapped to any value in this hashtable.
  Since:
    JDK1.0
  See Also:
    `put(java.lang.Object, java.lang.Object)`

### rehash

    protected void rehash()

  Rehashes the contents of the hashtable into a hashtable with a larger capacity. This method is called automatically when the number of keys in the hashtable exceeds this hashtable's capacity and load factor.

  Since:
    JDK1.0

### put

    public V put(K key,
                 V value)

  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.

  Parameters:
    `key` - the hashtable key.
    `value` - the value.
  Returns:
    the previous value of the specified key in this hashtable, or `null` if it did not have one.
  Throws:
    `NullPointerException` - if the key or value is `null`.
  Since:
    JDK1.0
  See Also:
    `Object.equals(java.lang.Object)`, `get(java.lang.Object)`

### remove

    public V remove(K key)

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

  Parameters:
    `key` - the key that needs to be removed.
  Returns:
    the value to which the key had been mapped in this hashtable, or `null` if the key did not have a mapping.
  Since:
    JDK1.0

### clear

    public void clear()

  Clears this hashtable so that it contains no keys.

  Since:
    JDK1.0

### toString

    public String toString()

  Returns a rather long string representation of this hashtable.

  Overrides:
    `toString` in class `Object`
  Returns:
    a string representation of this hashtable.
  Since:
    JDK1.0

### equals

    public boolean equals(Object o)

  Compares the specified object with this hashtable for equality. Returns `true` if the given object is also a hashtable and the two hashtables represent the same mappings.

  Overrides:
    `equals` in class `Object`
  Parameters:
    `o` - object to be compared for equality with this hashtable
  Returns:
    true if the specified Object is equal to this hashtable
  Since:
    1.2
  See Also:
    `Boolean.hashCode()`, `Hashtable`

### hashCode

    public int hashCode()

  Returns the hash code value for this hashtable. The hash code of a hashtable is defined to be the sum of the hash codes of each entry in the hashtable. This ensures that `m1.equals(m2)` implies that `m1.hashCode()==m2.hashCode()` for any two hashtables `m1` and `m2`, as required by the general contract of `Object.hashCode()`.

  Overrides:
    `hashCode` in class `Object`
  Returns:
    the hash code value for this hashtable
  Since:
    1.2
  See Also:
    `Object.equals(Object)`, `equals(Object)`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright (c) 2009 Sun Microsystems, Inc. All rights reserved.