Occurred order in the iteration at run-time in a map

Question

In the piece of code similar to

//something before
Iteration<String> iterator = hashMap.keySet().iterator();// HashMap<String, Document>
while(iterator.hasNext()){
      System.out.println(iterator.next());
}
//something after

I know that the order of print can be different by the order of insertion of entry key, value; all right.

But if I call this piece in another moment, with re-create the variable hashMap and putting them the equal elements, can the second-moment time print be different from the first-time print?

My question was born by a problem with a web-app: I have a list of String in a JSP, but, after some years, the customer call because the order of the String was different in the morning, but it shows the usual order at the afternoon.

The problem is happened in only one day: the web-app uses the explained piece of code for take a Map and populate an ArrayList.

This ArrayList does'nt any explicit changement of order (no Comparator or similar classes).

I think (hope) that the cause of different order of print derives by a different sequence of iteration in the same HashMap at run-time and I looking for a validation by other people.

In the web, I read that the iteration order by a HashMap changes if the HashMap receives a modification: but what happens if the HashMap remains the same?

Answer 1

Hash map document says HashMap makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time.

that explains though the hashmap is same it can not guaranatee on order. for Ordered map you can use TreeMap or LinkedHashMap

TreeMap API says The map is sorted according to the natural ordering of its keys, or by a Comparator provided at map creation time, depending on which constructor is used.

Answer 2

HashMap API documentation states that

This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time.

Answer 3

For a Map that keeps its keys in original insertion order, use LinkedHashMap.

For a Map that keeps its keys in sorted order (either natural order or by you passing a Comparator), use either TreeMap or ConcurrentSkipListMap. If multi-threaded, use the second.

For a Map where the key an enum, use EnumMap if you want the entries ordered by the definition order of the enum's objects.

The other six Map implementations bundled with Java 11 do not promise any order to their entries.

See this graphic table of mine as an overview.

Answer 4

Use a LinkedHashMap instead, to preserve insertion order. From the javadoc: "Hash table and linked list implementation of the Map interface, with predictable iteration order."

If you just want a Map with predictable ordering, then you can also use TreeMap. However, a LinkedHashMap is faster, as seen here: "TreeMap has O(log n) performance for containsKey, get, put, and remove, according to the Javadocs, while LinkedHashMap is O(1) for each."

As Octopus mentioned, HashMap "makes no guarantees as to the order of the map," and you shouldn't use it if order must remain consistent.