13

I have this very simple piece of code, and I was just trying to play a bit with different kind of objects inside a Map.

//There's a bit of spanish, sorry about that
//just think 'persona1' as an object with
//a string and an int
Map mapa = new HashMap();
mapa.put('c', 12850);
mapa.put(38.6, 386540);
mapa.put("Andrés", 238761);
mapa.put(14, "Valor de 14");
mapa.put("p1", persona1);
mapa.put("Andrea", 34500);

System.out.println(mapa.toString());

And then I expect from console something like:

{c=12850, 38.6=386540, Andrés=238761, 14=Valor de 14, p1={nombre: Andres Perea, edad: 10}, Andrea=34500}

But susprisingly for me I got same data in different order:

{38.6=386540, Andrés=238761, c=12850, p1={nombre: Andres Perea, edad: 10}, Andrea=34500, 14=Valor de 14}

It doesn't matter if I try other kind of objects, even just Strings or numeric types, it always does the same, it makes a different without-apparently-any-sense order.

Can someone give me a hint why this happens? Or may be something too obvious I'm missing?

I'm using Java 1.7 and Eclipse Juno.

Anirudha
  • 32,393
  • 7
  • 68
  • 89
unmultimedio
  • 1,224
  • 2
  • 13
  • 39
  • 2
    internally it uses array to store the values and those values are inserted at index computed by a hash function which converts the key to index..So the order would change depending on key. – Anirudha Sep 13 '13 at 04:46
  • that's a nice piece of info, I'll try some changes to see how it reacts – unmultimedio Sep 13 '13 at 04:48

5 Answers5

22

As per Oracle's documentation

The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls. 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.

Refer to HashMap JavaDocs.

Ravi K Thapliyal
  • 51,095
  • 9
  • 76
  • 89
Vimal Bera
  • 10,346
  • 4
  • 25
  • 47
  • 3
    guess I tried first here and since no one asked before I thought I would. next time I'll look docs first, thanks! – unmultimedio Sep 13 '13 at 04:44
  • Think that you're hashing your elements, so really, for a given set of elements {a, b, c}, you're using their hashcodes hash({a, b, c}), which have nothing to do with the order you entered the elements {a, b, c} – Joey Baruch Sep 11 '17 at 13:27
  • @joeybaruch but you can't predict hash value of each elements added in Map and bucket in which they are stored. During toString, it will scan all buckets from A to Z and print elements in A to Z bucket's order. – Vimal Bera Sep 15 '17 at 11:56
  • 1
    That's correct. I was just pointing out that there exists a single print order for a given set of elements and a deterministic hashmap (which it is in the case of java), and that it is dependant on the hash function, and not the insertion order. But yet, of all possible insertion orders, one of them is the same as the print order. The chance of randomly choosing it is given by 1/n! where n is the number of elements, and ! is factorial – Joey Baruch Sep 16 '17 at 13:21
16

There are 3 class which implements map interface in java. 1. hashMap: Id does not guarantee any order. 2. Linked HashMap:It will store them in insertion order. 3. TreeMap: It will store in ascending order.(ASCII value)

So As per your requirement you can use Linked HashMap instead of HashMap.so instead of writing 

Map mapa = new HashMap();

create object of Linked HashMap

Map mapa = new LinkedHashMap();

follow below link for more info.

http://docs.oracle.com/javase/tutorial/collections/interfaces/map.html

Suresh Atta
  • 120,458
  • 37
  • 198
  • 307
TheGraduateGuy
  • 1,450
  • 1
  • 13
  • 35
5

HashMap not guaranteed the order of element. If you want to keep order use LinkedHashMap.

See following case

    Map<Integer,String> unOrderedMap=new HashMap<>();
    unOrderedMap.put(1,"a");
    unOrderedMap.put(3,"a");
    unOrderedMap.put(2,"a");
    System.out.println("HashMap output: "+unOrderedMap.toString());

    Map<Integer,String> orderedMap=new LinkedHashMap<>();
    orderedMap.put(1,"a");
    orderedMap.put(3,"a");
    orderedMap.put(2,"a");
    System.out.println("LinkedHashMap output: "+orderedMap.toString());

Output: 

   HashMap output: {1=a, 2=a, 3=a}
   LinkedHashMap output: {1=a, 3=a, 2=a}
Ruchira Gayan Ranaweera
  • 34,993
  • 17
  • 75
  • 115
1

Maps does not maintain the order the order in which elements were added, List will maintain the order of elements

"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."

upog
  • 4,965
  • 8
  • 42
  • 81
0

This is how a hashmap works: (citing from another source)

It has a number of "buckets" which it uses to store key-value pairs in. Each bucket has a unique number - that's what identifies the bucket. When you put a key-value pair into the map, the hashmap will look at the hash code of the key, and store the pair in the bucket of which the identifier is the hash code of the key. For example: The hash code of the key is 235 -> the pair is stored in bucket number 235. (Note that one bucket can store more then one key-value pair).

When you lookup a value in the hashmap, by giving it a key, it will first look at the hash code of the key that you gave. The hashmap will then look into the corresponding bucket, and then it will compare the key that you gave with the keys of all pairs in the bucket, by comparing them with equals().

Now you can see how this is very efficient for looking up key-value pairs in a map: by the hash code of the key the hashmap immediately knows in which bucket to look, so that it only has to test against what's in that bucket.

Looking at the above mechanism, you can also see what requirements are necessary on the hashCode() and equals() methods of keys:

  • If two keys are the same (equals() returns true when you compare them), their hashCode() method must return the same number. If keys violate this, then keys that are equal might be stored in different buckets, and the hashmap would not be able to find key-value pairs (because it's going to look in the same bucket).

  • If two keys are different, then it doesn't matter if their hash codes are the same or not. They will be stored in the same bucket if their hash codes are the same, and in this case, the hashmap will use equals() to tell them apart.

Now, when you put all your "key-value" pairs in the hashmap, and print them, it prints them in some random order of the keys which got generated by hashing the value you supplied for keys.

If your requirement is still to maintain the ordering, you can use the LinkedHashMap in Java.

Hope this helps :-)

Edit: Original Post: How does a Java HashMap handle different objects with the same hash code?

JimHawkins
  • 4,843
  • 8
  • 35
  • 55
VictorCreator
  • 724
  • 1
  • 7
  • 17