Programming Exercise 4

In this exercise you will learn to use library data structures and also increase your "object" skills. The desired outcome is a hashtable that can store duplicates.

Recall the problem with Java's Hashtable: duplicates may not be stored. For example, consider:

  Hashtable h = new Hashtable ();
  h.put ("A", "AAA");   // Store the key "A" and value "AAA"
  h.put ("B", "BBB");   // Store the key "B" and value "BBB"
  h.put ("B", "BBBBB"); // This key-value pair replaces "B" and "BBB".

What we would like is a hashtable that stores duplicates. However, suppose we have a hashtable DupHashtable that stores duplicates, e.g.

  DupHashtable h = new DupHashtable ();
  h.put ("A", "AAA");   // Store the key "A" and value "AAA"
  h.put ("B", "BBB");   // Store the key "B" and value "BBB"
  h.put ("B", "BBBBB"); // Store the value "BBBBB" with existing key "B"

When we retrieve on a key, we could have a collection of values stored along with that one key. Thus, in retrieving, we need to be prepared to receive a collection of values. In other words, the equivalent in DupHashtable of the get() method in Hashtable should return a collection.

In this exercise, you are to implement the class DupHashtable and compare its performance with that of Hashtable:

Start by downloading the following template.
Your code will be written in the file DupHashtable.java.

This class has the following methods:

public class DupHashtable implements Enumeration {

  // Put a key-value combination into the table.
  public void put (Object key, Object value)
  {
  }
  
  // Given a key, return the (zero, one or many) values
  // associated with the key.
  public LinkedList get (Object key)
  {
  }

  // Return the number of values stored.
  public int size () 
  {
  }


  // Return an Enumeration of values in the hashtable.
  // This interface is to be implemented by DupHashtable itself.
  public Enumeration allValues ()
  {
  }
  
  
  // One of the two methods in the Enumeration interface.
  public boolean hasMoreElements ()
  {
  }
  
  // One of the two methods in the Enumeration interface.
  public Object nextElement ()
  {
  }

  // Some testing ...
  public static void main (String[] argv) 
  {
    // Test 1:
    DupHashtable dup = new DupHashtable ();
    dup.put ("A", "AAA");
    printTable (dup);

    // Test 2:
    dup = new DupHashtable ();
    dup.put ("A", "AAA");
    dup.put ("B", "BBB");
    dup.put ("C", "CCC");
    printTable (dup);

    // Test 3:
    dup = new DupHashtable ();
    dup.put ("A", "AAA");
    dup.put ("B", "BBB");
    dup.put ("C", "CCC");
    dup.put ("A", "AAAAA");
    dup.put ("C", "CCCCC");
    printTable (dup);
  }

  public static void printTable (DupHashtable dup)
  {
    System.out.println ("Hashtable with " + dup.size() + " values: ");
    Enumeration e = dup.allValues ();
    while (e.hasMoreElements()) {
      System.out.println (e.nextElement());
    }
  }

}

There is also a main method with some tests.

Recall that a hashtable is simply an array of lists. Now, one way to implement duplicates is to build a hashtable in which each list itself stores a list. This can be done with a custom implementation using linked-list code. However, we will take a much simpler approach. In this exercise, we will trick Java's hashtable into storing duplicates. How? For each key, we will store not a corresponding value, but a linked-list of values (which might contain just a single value). After all, Java's hashtable has no way of knowing that you are going to store linked-lists in it instead of actual values (like strings).
Instead of implementing a list, use Java's implementation of a linked list. The class is called, not surprisingly, LinkedList.

If all works, the output from the three tests in main should look like:

Hashtable with 1 values: 
AAA

Hashtable with 3 values: 
AAA
CCC
BBB

Hashtable with 5 values: 
AAA
AAAAA
CCC
CCCCC
BBB

For Test 3 above, draw a complete picture with every memory blob involved after the insertions are done.
Hint: the put and get methods are quite simple once you understand the idea. Doing the Enumeration is a little tricky but not much code. Overall, you won't need more than 50 lines, so you might be doing something wrong if it takes much more.
[10 bonus points] Finally, the last part of the exercise is to compare performance with Java's Hashtable. After all, DupHashtable should be slower since an entire list is stored for each value. Accordingly, what you should do is do a large number of put's and get's and record the total time required for all of them. Do this for the Hashtable and for DupHashtable and compare. To record the actual time taken (in milliseconds) for any snippet of code, record the system clock time in milliseconds just before and just after, using the the method System.currentTimeMillis().

Submission:

Submit the source code as before, in an encrypted tar-file. This time, the name of subdirectory for this exercise should be: your username followed by 4.
Follow the submission instructions carefully as usual.
Submit a printout (hardcopy) of your code before the due date in my mailbox.