From what I can see (according to ++), you would like to append Array, with one more element. But Array fixed length structure, so instead I'd recommend to use Vector. Because, I suppose, you are using immutable Map you need update it as well.

So the final solution might look like:

var values: Map[String, Vector[Float]] = Map()
val key = "key1"
val value = 1.0
values = values + (key -> (values.getOrElse(key, Vector.empty[Float]) :+ value))

Hope this helps!

Immutable vs Mutable Collections

You need to choose what type of collection you will use immutable or mutable one. Both are great and works totally differently. I guess you are familiar with mutable one (from other languages), but immutable are default in scala and probably you are using it in your code (because it doesn't need any imports). Immutable Map cannot be changed... you can only create new one with updated values (Tim's and Ivan's answers covers that).

There are few ways to solve your problem and all are good depending on use case.

See implementation below (m1 to m6):

//just for convenience 
type T = String
type E = Long

import scala.collection._

//immutable map with immutable seq (default).
var m1 = immutable.Map.empty[T,List[E]] 

//mutable map with immutable seq. This is great for most use-cases.
val m2 = mutable.Map.empty[T,List[E]]

//mutable concurrent map with immutable seq.
//should be fast and threadsafe (if you know how to deal with it) 
val m3 = collection.concurrent.TrieMap.empty[T,List[E]] 

//mutable map with mutable seq.
//should be fast but could be unsafe. This is default in most imperative languages (PHP/JS/JAVA and more).
//Probably this is what You have tried to do
val m4 = mutable.Map.empty[T,mutable.ArrayBuffer[E]] 

//immutable map with mutable seq.
//still could be unsafe 
val m5 = immutable.Map.empty[T,mutable.ArrayBuffer[E]] 
//immutable map with mutable seq v2 (used in next snipped)
var m6 = immutable.Map.empty[T,mutable.ArrayBuffer[E]]

//Oh... and NEVER DO THAT, this is wrong
//I mean... don't keep mutable Map in `var`
//var mX = mutable.Map.empty[T,...]

Other answers show immutable.Map with immutable.Seq and this is preferred way (or default at least). It costs something but for most apps it is perfectly ok. Here You have nice source of info about immutable data structures: https://stanch.github.io/reftree/talks/Immutability.html.

Each variant has it's own Pros and Cons. Each deals with updates differently, and it makes this question much harder than it looks at the first glance.

Solutions

val k = "The Ultimate Answer"
val v = 42f

//immutable map with immutable seq (default).
m1 = m1.updated(k, v :: m1.getOrElse(k, Nil))

//mutable map with immutable seq.
m2.update(k, v :: m2.getOrElse(k, Nil))

//mutable concurrent map with immutable seq.
//m3 is bit harder to do in scala 2.12... sorry :)

//mutable map with mutable seq.
m4.getOrElseUpdate(k, mutable.ArrayBuffer.empty[Float]) += v

//immutable map with mutable seq.
m5 = m5.updated(k, {
  val col = m5.getOrElse(k, c.mutable.ArrayBuffer.empty[E])
  col += v
  col
})

//or another implementation of immutable map with mutable seq.
m6.get(k) match {
  case None => m6 = m6.updated(k, c.mutable.ArrayBuffer(v))
  case Some(col) => col += v
}

check scalafiddle with this implementations. https://scalafiddle.io/sf/WFBB24j/3. This is great tool (ps: you can always save CTRL+S your changes and share link to write question about your snippet).

Oh... and if You care about concurrency (m3 case) then write another question. Such topic deserve to be in separate thread :)

(im)mutable api VS (im)mutable Collections

You can have mutable collection and still use immutable api that will copy orginal seq. For example Array is mutable:

val example = Array(1,2,3) 
example(0) = 33 //edit in place
println(example.mkString(", ")) //33, 2, 3

But some functions on it (e.g. ++) will create new sequence... not change existing one:

val example2 = example ++ Array(42, 41) //++ is immutable operator
println(example.mkString(", ")) //33, 2, 3  //example stays unchanged
println(example2.mkString(", ")) //33, 2, 3, 42, 41 //but new sequence is created

There is method updateWith that is mutable and will exist only in mutable sequences. There is also updatedWith and it exists in both immutable AND mutable collections and if you are not careful enough you will use wrong one (yea ... 1 letter more).

This means you need to be careful which functions you are using, immutable or mutable one. Most of the time you can distinct them by result type. If something returns collection then it will be probably some kind of copy of original seq. It result is unit then it is mutable for sure.

You can use Scala 2.13's transform function to transform your map anyway you want.

val values = Map("key" -> Array(1f, 2f, 3f), "key2" -> Array(4f,5f,6f))

values.transform {
  case ("key", v) => v ++ Array(6f)
  case (_,v) => v
}

Result:

Map(key -> Array(1.0, 2.0, 3.0, 6.0), key2 -> Array(4.0, 5.0, 6.0))

Note that appending to arrays takes linear time so you might want to consider a more efficient data structure such as Vector or Queue or even a List (if you can afford to prepend rather than append).

Update:

However, if it is only one key you want to update, it is probably better to use updatedWith:

values.updatedWith("key")(_.map(_ ++ Array(6f)))

which will give the same result. The nice thing about the above code is that if the key does not exist, it will not change the map at all without throwing any error.