The goal of this lab is to practice writing generic classes. In class we have seen examples of generic linked lists and a generic ArrayList-like class. In this lab we will write a generic class that will be something similar to a HashMap.
A map (also called a dictionary or associative array)
associates keys with values.
See the
Map in Java's API as an example
of the functionality.
We will use a simplified version of this interface in the lab. Your main task in this lab is to implement this interface.
As usual, make a directory for this lab. Copy the following code from the public directory.
cp /homes/tvandrun/Public/cs245/lab8/* .
Open Eclipse and make a new project from the existing source in your directory.
Next, look at the driver program, SLMDriver.java,
so that you see what the map will be used for.
Basically it will be used to tally the frequencies of words in
a file.
You may remember this example from Lab 4.
On the inside, your class will be a linked list. Think about how you would implement such a think as a linked list, consider how it would need to be different from the linked lists we've already seen, and how the specific operations would be defined.
This map, however, will have a special feature.
Java's HashMap orders associations in an unpredictable order---
if you iterated through the key set, you would not get the keys in
the same order that you added them, nor would there be any clear
reason for the order that they would be iterated through.
Your map, however, will take a Comparator<K> object
in its constructor---that is, a comparator with the same parameterized
type as the key type.
This will determine how the associations are ordered
and what order the keys come when using keyIterator().
Oh, and resist the temptation to refer to your class as a hash map. The "hash" in "hashmap" refers to a specific way to implement a map (or set). We are not doing hashing in this lab. But we will learn about hashing later in the semester.
Finally, before you move on discuss with your partner and decide the basic structure of your classes. How will you implement the map as a linked list? What will your node class look like? You may make your node class either as a stand-alone class or as a nested class.
SortedListMap classNow, open SortedListMap,
understand the parts of the code given to you
(the nested Node class, the constructor,
containsKey(),
and get()).
Your task is to write the keyIterator() method
(writing an anonymous inner class for the iterator being returned)
and to write the put() method
(making use of the Comparator passed
in to the constructor).
When you are ready to test your SortedListMap,
you'll also need to write a comparator.
In this case, we want the key/value associations stored
in alphabetical order of the keys.
You will write a comparator for strings that performs that
comparison.
(The comparison itself is very easy, because String
already has a compareTo() method which
does exactly that comparison.)
However, instead of writing a plain old class that implements
Comparator, practice nested classes by
writing an anonymous inner class.
Change the line in SLMDriver
that reads
Map<String, Integer> tally = null; //new SortedListMap<String, Integer>(...your comparator...);
to
Map<String, Integer> tally = new SortedListMap<String, Integer>(...your comparator...);
except write your anonymous inner class in place of "...your comparator...".