If you use immutable maps, you can use the – method to create a new map without the given key: val mx = Map(“data” -> “sumi”, “rel” -> 2, “privacy” -> 0) val m = mx(“privacy”) match { case 0 => mx – “data” case _ => mx } => m: scala.collection.immutable.Map[String,Any] = Map(rel -> … Read more
From the LinkedHashMap Scaladoc page: “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.”
Since 2.8 Scala has had .toMap, so: val map = seq.map(a => a.key -> a).toMap or if you’re gung ho about avoiding constructing an intermediate sequence of tuples, then in Scala 2.8 through 2.12: val map: Map[Int, A] = seq.map(a => a.key -> a)(collection.breakOut) or in Scala 2.13 and 3 (which don’t have breakOut, but … Read more
Edit: the recommended way is now to use JavaConverters and the .asScala method: import scala.collection.JavaConverters._ val myScalaMap = myJavaMap.asScala.mapValues(_.asScala.toSet) This has the advantage of not using magical implicit conversions but explicit calls to .asScala, while staying clean and consise. The original answer with JavaConversions: You can use scala.collection.JavaConversions to implicitly convert between Java and Scala: … Read more
Why not to use withDefaultValue(value)? scala> val m = Map[Int, List[String]]().withDefaultValue(List()) m: scala.collection.immutable.Map[Int,List[String]] = Map() scala> m(123) res1: List[String] = List()
The main difference between a Stream and an Iterator is that the latter is mutable and “one-shot”, so to speak, while the former is not. Iterator has a better memory footprint than Stream, but the fact that it is mutable can be inconvenient. Take this classic prime number generator, for instance: def primeStream(s: Stream[Int]): Stream[Int] … Read more
I’m not sure about the error, but you can achieve what you want as follows: m.foreach(p => println(“>>> key=” + p._1 + “, value=” + p._2)) That is, foreach takes a function that takes a pair and returns Unit, not a function that takes two arguments: here, p has type (String, Int). Another way to … Read more
Views are non-strict versions of collections. This means that the elements are calculated at access and not eagerly as in normal collections. As an example take the following code: val xs = List.tabulate(5)(_ + 1) val ys = xs.view map { x => println(x); x * x } Just this will not print anything but … Read more
The above is all true, but there is one more thing that is handy: flatMap turns a List[Option[A]] into List[A], with any Option that drills down to None, removed. This is a key conceptual breakthrough for getting beyond using null.
The Scala collections library provides specialised implementations for Sets of fewer than 5 values (see the source). The iterators for these implementations return elements in the order in which they were added, rather than the consistent, hash-based ordering used for larger Sets. Furthermore, sameElements (scaladoc) is defined on Iterables (it is implemented in IterableLike – … Read more