A HashMap lets you look up values by exact key (always
case-sensitive). It is very much like a Hashtable,
except that it is faster and not thread-safe. There are some minor other
differences:
- HashMaps work with Iterators
where the older Hashtables work with Enumerations
- Hashtables work best with capacities that are prime
numbers. HashMaps round capacities up to powers of
two.
Read the Hashtable
entry. Nearly all of it also applies to HashMap,
The capacity of a table is not the number of
elements you plan to add! If you specify a capacity of 128 and a load factor of .75,
HashMap will allocate only 128 slots, not the 256
you need for efficient access. The load factor kicks in only when deciding when
it is time to double the size of the table, in this case, just after you have
added 96 elements, not in deciding its initial size. It is up to you to leave
some breathing room.
Sample Use
In this case we use a String to look up a String in
a HashMap. We use the modern JDK 1.5+ techniques of
generics and for:each loops.
AutoBoxing Enumerations
}
In this case we use a String to look up a number in
a HashMap. We use the JDK 1.5+ autoboxing features and the JDK 1.5+ style for:each
loop.
Old Style Manual Boxing Enumerations
In this case we use a String to look up a number in
a HashMap. We use the JDK 1.1+ manual boxing and the
old style for loop. We don’t use generics type checking.
Accumulate: A Real World Code Example
The Accumulate class uses a HashMap
to accumulate values against a variety of categories. Source is included. You
might use it to accumulate hours by category in a timesheet, or count how many
times various words appeared in a document. Studying the source will give you
some hints on what you can do with HashMaps. Here is
how you use it:
IdentityHashMap
IdentityHashMap uses ==
instead of equals to compare objects for equality.
It also uses the original Object. hashCode()
via System.identityHashCode(
Object x). This is useful
when you want a HashMap that keeps track of a set of
heterogeneous objects. Serialisation uses one to track which objects have
already been sent to the stream and where in the stream they are.
Having Your Cake and Eating It Too
Let’s say you can’t decide between the speed of an ArrayList
that looks up by an indexing int and TreeMap
that looks up by surname and a HashMap that looks up
by social insurance number.
The beauty of Java Collections is you can have
have all three. Just maintain three different Collections
on the same set of objects. The three Collections
don’t have to contain the exact same elements.
HashMap will give you an Iterator
or an array of the whole collection at any point, which may be sufficient so
that you don’t need an auxiliary ArrayList.
Learning More
Sun’s Javadoc on the
HashMap class : available:
Sun’s Javadoc on the
Set interface returned by keySet and entrySet class : available:
Sun’s Javadoc on the
IdentityHashMap class : available:
Sun’s Javadoc on
java.
util.Map : available:
Sun’s Javadoc on the
HashSet class : available:
To understand HashMap, read up on Hashtable
and HashCode.