toMap function is shuffling my elements, why is that and how can I prevent it

.toMap shuffles my Items around / changes the order they were in, this messes with other parts of my code.

For example:

val seq = Seq("Test" -> DBType.Int, "Test2" -> DBType.Int, "Test3" -> DBType.Int);

val seqMap = seq.toMap;

println(seqMap)

The Output of this will be as expected:

Map(Test -> Int, Test2 -> Int, Test3 -> Int)

However, if I add more elements like this it gets weird:

val seq = Seq("Test" -> DBType.Int, "Test2" -> DBType.Int, "Test3" -> DBType.Int, "Test4" -> DBType.Int, "Test5" -> DBType.Int, "Test6" -> DBType.Int);
val seqMap = seq.toMap;

println(seqMap);

This will, and I really wanna know why, output this (the order has changed):

HashMap(Test3 -> Int, Test6 -> Int, Test5 -> Int, Test -> Int, Test4 -> Int, Test2 -> Int)

What the heck ? Did I not format it correctly ? Did I miss a comma ? I am really at the end of my expertise here.

I tried debugging it for almost an hour and a half but could not fix it. My idea would be that the .toMap function reshuffles the entire thing due to it being a HashMap now rather than a map, maybe the code in the background functions differently.

I am expecting my Seq of Tuples to be matches in order by the Map, as I need the keys to be in a specific (given) order.

I really hope someone can enlighten my why it behaves like this. I also did some google-ing but it just said: Use a Seq ! Well - duh - I am.

If you guys need more information on my code / problem feel free to comment.

EDIT: I am trying to join two tables together. One has a particular order of attributes and the other as well. My task is to join them in a fashion that the attributes of table 2 are being appended to those from table one. This however I have already managed. My problem is that the constructor of the schema class which is required to create a table wants to put these attributes in a map with the type they hold, f.e.: ("grade" -> Double)

So my order matters in that sens that the tests I am trying to full fill require me to have a specific order.

By default, Maps and Sets in Scala do not give any guarantee with regards to the order in which items are returned when iterating over them one by one. The only base collection to do so is the Seq.

You can learn more about Maps in Scala here. The documentation has also a page describing several concrete implementations of the Map trait which can suit you:

• VectorMap, and
• ListMap

ListMap was also mentioned in a comment and you can use it as in the following example.

import scala.collection.immutable.ListMap

val seq = Seq("Test" -> 1, "Test2" -> 2, "Test3" -> 3)

seq.to(ListMap).foreach(println)

/* prints:
 *
 * ```
 * (Test,1)
 * (Test2,2)
 * (Test3,3)
 * ```
 */

You can play around with this code here on Scastie.

Expanding on that, note however that certain operations scale badly for this type, as explained in the documentation:

> Entries are stored internally in reversed insertion order, which means the newest key is at the head of the list. As such, methods such as head and tail are O(n), while last and init are O(1). Other operations, such as inserting or removing entries, are also O(n), which makes this collection suitable only for a small number of elements.

If apart from insertion order you might be able to rely on some form ordering (e.g. the lexicographical order of the keys), you can use a SortedMap as well.

If you are open to using a mutable data structure, Scala also has its own LinkedHashMap (another one suggested in a comment above):

> This class implements mutable maps using a hashtable. The iterator and all traversal methods of this class visit elements in the order they were inserted.

Finally, you can also use Java's LinkedHashMap:

> Hash table and linked list implementation of the Map interface, with predictable iteration order. This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order). Note that insertion order is not affected if a key is re-inserted into the map. (A key k is reinserted into a map m if m.put(k, v) is invoked when m.containsKey(k) would return true immediately prior to the invocation.)