Does HashTable maintains the insertion order?

The following code gives me the output in the same order of insertion. I read the javadoc and they did not even talk about the insertion order. Can someone help me to get the right information.

import java.util.*;

public class hash {

public static void main(String[] args) {

    String str[] = { "japan",
            "usa",
            "japan",
            "russia",
            "usa",
            "japan",
            "japan",
            "australia"};
    int len = 8;
    Hashtable ht = new Hashtable();
    int i = 0;
    while (i < len) {

        String c = str[i];
        System.out.println("c :" + c);
        Integer intg = (Integer) ht.get(c);

        if (intg == null)
            ht.put(开发者_开发知识库c, new Integer(1));
        else
            ht.put(c, new Integer(intg.intValue() + 1));

        i++;
    }

    Enumeration k = ht.keys();

    while (k.hasMoreElements()) {
        String key = (String) k.nextElement();
        System.out.println(key + " > " + ht.get(key));
    }
}
}

No, it does not. To preserve insertion order, instead use java.util.LinkedHashMap (javadoc).

Also, HashMap is now preferred over Hashtable, because Hashtable has unnecessary concurrency overhead. (See Differences between HashMap and Hashtable?.)

no, it does not. it only knows the "hash" order. if you reorder the strings, you will find they still appear in the same order from the hashtable.

Hashtable is used for fast lookup not for maintaining order. You should look into LinkedHashMap or other data structures.

LinkedHashMap is used for maintaining order of inserting elements.. Hashtable is similar to HashMap but it doesn't allow null key or value while HashMap allows one null key and several null values...

From Map Javadoc.

The order of a map is defined as the order in which the iterators on the map's collection views return their elements. Some map implementations, like the TreeMap class, make specific guarantees as to their order; others, like the HashMap class, do not.

Also it's very useful to look inside the code of Hashtable and HashMap.