Hashtable - jdk1.2 vs jdk1.3

Question

hash is Hashtable
for (Enumeration e = hash.keys() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());
This program prints the elements in a different order
under jdk1.2 and jdk1.3. This means the hashtable
implementation is different under these two versions.
Am I correct?
I know I am not supposed to rely on this order, but
unfortunately significantly large part of a code
uses this order. and my transition to jdk1.3 fails.
and jdk1.2 doesnt work on RH7.1 ;-(
Is there something I can do or am I totally out of luck?
thanks
Santosh

Answer 1

I believe I had a mental lapse when I wrote my last post. The problem has to do with the initial table capacity. In JDK 1.2 the default capacity is 101. In JDK 1.3 the default capacity is 11.
The hashcodes for the strings "a", "b", and "c" are 97, 98, and 99 respectively. In JDK 1.2 these were simple placed in the table array at the index with the same value as the hashcode. Enumeration of the keys results in iterating over all non-null elements in the table array starting with the last array element. This results in an ordering of the elements by index which produces c b a.
In JDK 1.3 the hashcodes for the strings "a", "b", and "c" are the same as in JDK 1.2 but they are placed at different indices in the table array. In this case "a" is at index 9, "b" is at index 10, and "c" is at index 0. Enumeration of the keys still results in iteration over all non-null elements in the table array starting with the last element. However due to the different element positions the output is b a c.
This trivial case can be solved by simply creating a Hashtable in JDK 1.3 with an initial capacity of 101. Try running the code below using JDK 1.2 and JDK 1.3. You will find that the Hashtable with an initial capacity of 101 produces the same results in the two different JVMs.Hashtable htab1 = new Hashtable();
htab1.put(new String("a"), new String("element1"));
htab1.put(new String("b"), new String("element2"));
htab1.put(new String("c"), new String("element3"));
System.out.println("Hashtable 1 with default capacity");
for (java.util.Enumeration e = htab1.keys(); e.hasMoreElements();) {
   String key = (String) e.nextElement();
   System.out.println("hash:" + key.hashCode() + " key:" + key);
Hashtable htab2 = new Hashtable(101);
htab2.put(new String("a"), new String("element1"));
htab2.put(new String("b"), new String("element2"));
htab2.put(new String("c"), new String("element3"));
System.out.println("Hashtable 2 with capacity of 100");
for (java.util.Enumeration e = htab2.keys(); e.hasMoreElements();) {
   String key = (String) e.nextElement();
   System.out.println("hash:" + key.hashCode() + " key:" + key);
}To start solving your problem you will need to determine if there are differences in the way elements are placed in the table array and in the way the table is rehashed.