Hashtable in Java

You can either look at the hashtable at runtime in debug mode, or analyze the content of the hashtable using this program.
The class Key is a class that used a an intentionally bad key, that will generate a lot of collisions.
you can analyze your own hashtable, with the getCollisionsMap() method.


import java.util.*;
import java.util.Enumeration;
import java.util.Hashtable;

class Key
{
      public static int COLLISION_FACTOR = 10;
      
      Integer m_int;
      
      public Key(int i)
      {
            m_int = new Integer(i);
      }
      
      public int hashCode()
      {
            // this will make collisions VERY likely
            return m_int.intValue() % COLLISION_FACTOR;
      }
}

public class Main
{
      public static void main(String[] args)
      {
            Hashtable hashtable = new Hashtable();
            
            final int MAX = 20;
            
            // populate the hashtable with 100 random keys.
            // each can be is an integer between 0 and MAX - 1
            for (int i = 0; i < 1000; i++)
            {
                  Object key = new Key((int)(Math.random() * MAX));
                  Object value = "Value for " + key;
                  hashtable.put(key, value);
            }
            
            TreeMap collisions = getCollisionsMap(hashtable);
                        
            printMap(collisions);
      }

      private static TreeMap getCollisionsMap(Hashtable hashtable)
      {
            // a TreeMap that will map each hashcode from the previous
            // hashtable to the number of collisions it had.
            // I used TreeMap just to keep the result sorted.
            final TreeMap collisions = new TreeMap();
            
            // scan the hashtable for colissions.
            
            
            Enumeration keys = hashtable.keys();
            while (keys.hasMoreElements())
            {
                  Object key = (Object) keys.nextElement();
                  Integer hash = new Integer(key.hashCode());
                  Integer value = (Integer) collisions.get(hash);
                  if (value == null) // new hashcode
                  {
                        // we have 1 occurence of this hashcode so far.
                        collisions.put(hash, new Integer(1));      
                  }
                  else
                  {
                        // increas the number of occurences for this
                        // hash code (we have a colission).
                        value = new Integer(value.intValue() + 1);
                        collisions.put(hash, value);
                  }
            }
            
            return collisions;
      }

      private static void printMap(TreeMap collisions)
      {
            Iterator keys = collisions.keySet().iterator();
            while (keys.hasNext())
            {
                  Object key = keys.next();
                  System.out.println(key + " = " + collisions.get(key));
            }
      }
}