Question

I have a LinkedHashMap which I’ve been using in a typical way: adding new key-value
pairs to the end, and accessing them in order of insertion. However, now I have a
special case where I need to add pairs to the “head” of the map. I think there’s
some functionality inside the LinkedHashMap source for doing this, but it has private
accessibility.

I have a solution where I create a new map, add the pair, then add all the old mappings.
In Java syntax:

newMap.put(newKey, newValue) 
newMap.putAll(this.map)
this.map = newMap

It works. But the problem here is that I then need to make my main data structure
(this.map) a var rather than a val.

Can anyone think of a nicer solution? Note that I definitely need the fast lookup
functionality provided by a Map collection. The performance of a prepending is not
such a big deal.

More generally, as a Scala developer how hard would you fight to avoid a var
in a case like this, assuming there’s no foreseeable need for concurrency?
Would you create your own version of LinkedHashMap? Looks like a hassle frankly.

Answer 1

This will work but is not especially nice either:

import scala.collection.mutable.LinkedHashMap

def prepend[K,V](map: LinkedHashMap[K,V], kv: (K, V)) = {
  val copy = map.toMap
  map.clear
  map += kv
  map ++= copy
}

val map = LinkedHashMap('b -> 2)
prepend(map, 'a -> 1)
map == LinkedHashMap('a -> 1, 'b -> 2)