Learn Scala Map with Examples Quickly & Effectively

Free Scala course with real-time projects Start Now!!

In this tutorial on Scala Map, we will see how to define and process maps, and what methods to call on them. We will learn to declare a Scala Map, Operations on a Map in Scala, Concatenating Maps, Printing Keys and Values from a Scala Map, Searching for a Key in a Map, Methods to Call on a Map etc.

So, let’s begin Scala Map Tutorial.

An Introduction to Maps in Scala

A Map in Scala is a collection of key-value pairs, and is also called a hash table. We can use a key to access a value. These keys are unique; however, the values may be common. The default Scala Map is immutable. To use a mutable Map, we use the scala.collection.mutable.Map class.

To use both in the same place, refer to the immutable Map as Map, and to the mutable Map as mutable.Map. I also recommend you refer our latest blog on Scala Closures which is explained in detail with Examples. For now let’s jump to learn to declare a Scala Map.

Declaring a Scala Map

We can either declare an empty Scala map or one with values.

a. Declaring an Empty Scala Map

scala> var m:Map[String,Int]=Map()
m: Map[String,Int] = Map()

Here, we must include the type annotation so it can assign proper types to the variables.

b. Declaring a Scala Map with Values

When we provide values, Scala will use those to infer the type of variables. So, we don’t need to include the type annotations.

scala> var m=Map("Ayushi"->0,"Megha"->1)
m: scala.collection.immutable.Map[String,Int] = Map(Ayushi -> 0, Megha -> 1)

Now, to add a key-value pair to this, we do the following:

scala> m+=("Ruchi"->2)
scala> m
res1: scala.collection.immutable.Map[String,Int] = Map(Ayushi -> 0, Megha -> 1, Ruchi -> 2)

Learn: Scala Arrays and Multidimensional Arrays in Scala

Operations on a Map in Scala

Technology is evolving rapidly!
Stay updated with DataFlair on WhatsApp!!

These are the basic operations we can carry out on a Map:

a. keys

This returns an iterable with each key in the Map.

scala> m.keys
res2: Iterable[String] = Set(Ayushi, Megha, Ruchi)
scala> m("Megha")
res56: Int = 1

b. values

This returns an iterable with each value in the Scala Map.

scala> m.values
res3: Iterable[Int] = MapLike.DefaultValuesIterable(0, 1, 2)

c. isEmpty

If the Map is empty, this returns true; otherwise, false.

scala> m.isEmpty
res4: Boolean = false
scala> Map().isEmpty
res5: Boolean = true

Concatenating Maps in Scala

We can concatenate/joing two Maps in more than one way. Let’s take another Scala Map for this.

scala> var m1=Map("Megha"->3,"Ruchi"->2,"Becky"->4)
m1: scala.collection.immutable.Map[String,Int] = Map(Megha -> 3, Ruchi -> 2, Becky -> 4)

The ++ Operator

scala> m++m1
res6: scala.collection.immutable.Map[String,Int] = Map(Ayushi -> 0, Megha -> 3, Ruchi -> 2, Becky -> 4)
scala> m1++m
res7: scala.collection.immutable.Map[String,Int] = Map(Megha -> 1, Ruchi -> 2, Becky -> 4, Ayushi -> 0)

See the difference in the values for “Megha” in both cases?
Learn: Scala Operator

Printing Keys and Values from a Map

We can use a foreach loop to walk through the keys and values of a Scala Map:

scala> m.keys.foreach{i=>println(i+" "+m(i))}

Ayushi 0
Megha 1
Ruchi 2

Searching for a Key in a Scala Map

The Map.contains() method will tell us if a certain key exists in the Map.

scala> m.contains("Ayushi")
res10: Boolean = true
scala> m.contains("Fluffy")
res11: Boolean = false

Any Doubt yet in Scala Map? Please Comment.

Methods to Call on a Scala Map

We can call the following methods on a Map. (Note that they don’t modify the original Scala Map)

a. def ++(xs: Map[(A, B)]): Map[A, B]

This concatenates two Maps.

scala> m.++(m1)
res15: scala.collection.immutable.Map[String,Int] = Map(Ayushi -> 0, Megha -> 3, Ruchi -> 2, Becky -> 4)
scala> m1.++(m)
res16: scala.collection.immutable.Map[String,Int] = Map(Megha -> 1, Ruchi -> 2, Becky -> 4, Ayushi -> 0)

b. def -(elem1: A, elem2: A, elems: A*): Map[A, B]

This returns a new Map eliding the pairs for the keys mentioned in the arguments.

scala> m.-("Ayushi","Ruchi")
res21: scala.collection.immutable.Map[String,Int] = Map(Megha -> 1)

c. def get(key: A): Option[B]

This returns the value associated with the key; it returns this as an Option.

scala> m.get("Megha")
res27: Option[Int] = Some(1)
scala> m.get("Fluffy")
res28: Option[Int] = None

d. def iterator: Iterator[(A, B)]

This returns an iterator over the Scala Map.

scala> m.iterator
res29: Iterator[(String, Int)] = non-empty iterator

Learn: Scala Arrays and Multidimensional Arrays in Scala

e. def addString(b: StringBuilder): StringBuilder

This appends all elements of the Map to the String Builder.

scala> m.addString(new StringBuilder())
res30: StringBuilder = Ayushi -> 0Megha -> 1Ruchi -> 2

f. def addString(b: StringBuilder, sep: String): StringBuilder

This does what the above method does, except it introduces a separator between the pairs.

scala> m.addString(new StringBuilder(),"*")
res31: StringBuilder = Ayushi -> 0*Megha -> 1*Ruchi -> 2

g. def apply(key: A): B

This searches for a key in the Scala Map.

scala> m.apply("Fluffy")
java.util.NoSuchElementException: key not found: Fluffy
 at scala.collection.immutable.Map$Map3.apply(Map.scala:167)
 ... 28 elided
scala> m.apply("Ayushi")
res33: Int = 0

h. def clear(): Unit

This actually removes all bindings from the Map in Scala.

scala> import scala.collection.mutable.Map
import scala.collection.mutable.Map
scala> var m2=scala.collection.mutable.Map("One"->1,"Two"->2,"Three"->3)
m2: scala.collection.mutable.Map[String,Int] = Map(One -> 1, Two -> 2, Three -> 3)
scala> m2.clear()
scala> m2
res36: scala.collection.mutable.Map[String,Int] = Map()

Doing this to m1 will result in the following error:

scala> m1.clear()
<console>:13: error: value clear is not a member of scala.collection.immutable.Map[String,Int]
      m1.clear()
         ^

i. def clone(): Map[A, B]

This creates a clone/copy of the receiver object.

We can’t clone an immutable Map in Scala. So, let’s revive m2.

scala> var m2=scala.collection.mutable.Map("One"->1,"Two"->2,"Three"->3)
m2: scala.collection.mutable.Map[String,Int] = Map(One -> 1, Two -> 2, Three -> 3)
scala> m2.clone()
res38: scala.collection.mutable.Map[String,Int] = Map(One -> 1, Two -> 2, Three -> 3)

j. def contains(key: A): Boolean

If the Map contains this key, this returns true; otherwise, false.

scala> m.contains("Megha")
res40: Boolean = true
scala> m.contains("Fluffy")
res41: Boolean = false

k. def copyToArray(xs: Array[(A, B)]): Unit

This fills key-value pairs from the Map into an Array.

scala> var arr:Array[Any]=Array(0,0,0,0,0,0,0,0)
arr: Array[Any] = Array(0, 0, 0, 0, 0, 0, 0, 0)
scala> m.copyToArray(arr)
scala> arr
res47: Array[Any] = Array((Ayushi,0), (Megha,1), (Ruchi,2), 0, 0, 0, 0, 0)

l. def count(p: ((A, B)) => Boolean): Int

This returns the number of key-value pairs in the Scala Map that satisfy the given predicate.

scala> m.count(x=>true)
res49: Int = 3

Learn: Tuples in Scala – A Quick and Easy Tutorial

m. def drop(n: Int): Map[A, B]

This returns all elements except the first n.

scala> m.drop(2)
res59: scala.collection.immutable.Map[String,Int] = Map(Ruchi -> 2)

n. def dropRight(n: Int): Map[A, B]

This returns all elements except the last n.

scala> m.dropRight(2)
res60: scala.collection.immutable.Map[String,Int] = Map(Ayushi -> 0)

o. def dropWhile(p: ((A, B)) => Boolean): Map[A, B]

This drops pairs until the predicate becomes false for a pair.

scala> m.dropWhile(x=>false)
res61: scala.collection.immutable.Map[String,Int] = Map(Ayushi -> 0, Megha -> 1, Ruchi -> 2)

p. def empty: Map[A, B]

This returns an empty Map of the same kind.

scala> m.empty
res68: scala.collection.immutable.Map[String,Int] = Map()

q. def equals(that: Any): Boolean

This returns true if both Maps contain the same key-value pairs; otherwise, false.

scala> m.equals(m1)
res69: Boolean = false

r. def exists(p: ((A, B)) => Boolean): Boolean

If the predicate holds true for some elements of the  Scala Map, this returns true; otherwise, false.

s. def filter(p: ((A, B))=> Boolean): Map[A, B]

This returns all such elements (see above).

t. def filterKeys(p: (A) => Boolean): Map[A, B]

This returns all pairs where the key satisfies the predicate.

u. def find(p: ((A, B)) => Boolean): Option[(A, B)]

This returns the first element that satisfies the predicate.

v. def foreach(f: ((A, B)) => Unit): Unit

This applies the function to all elements of the Scala Map.

w. def init: Map[A, B]

This returns all elements except the last.

scala> m.init
res82: scala.collection.immutable.Map[String,Int] = Map(Ayushi -> 0, Megha -> 1)

x. def isEmpty: Boolean

If the Map is empty, this returns true; otherwise, false.

scala> m.isEmpty
res83: Boolean = false

y. def keys: Iterable[A]

This returns an iterator over all keys in the Map.

scala> m.keys
res84: Iterable[String] = Set(Ayushi, Megha, Ruchi)

z. def last: (A, B)

This returns the last element from the Map in Scala.

scala> m.last
res85: (String, Int) = (Ruchi,2)

aa. def max: (A, B)

This returns the largest element.

scala> m.max
res86: (String, Int) = (Ruchi,2)

ab. def min: (A, B)

This returns the smallest element.

scala> m.min
res87: (String, Int) = (Ayushi,0)

ac. def mkString: String

This represents the elements of the Map as a String.

scala> m.mkString
res88: String = Ayushi -> 0Megha -> 1Ruchi -> 2

ad. def product: (A, B)

This returns the product of all elements of the Scala Map.

ae. def remove(key: A): Option[B]

This removes a key from the Map and returns the value. Let’s take a new Map for this.

scala> var d=Map(1->2,3->4,5->6)
d: scala.collection.mutable.Map[Int,Int] = Map(5 -> 6, 1 -> 2, 3 -> 4)
scala> d.remove(3)
res93: Option[Int] = Some(4)

af. def retain(p: (A, B) => Boolean): Map.this.type

This retains, in the Map, only the pairs that satisfy the predicate.

Learn: Scala Functions: Quick and Easy Tutorial

ag. def size: Int

This returns the number of elements in the Map.

scala> m.size
res94: Int = 3

ah. def sum: (A, B)

This returns the sum of all elements in the Map in Scala.

ai. def tail: Map[A, B]

This returns all elements except the first.

scala> m.tail
res97: scala.collection.immutable.Map[String,Int] = Map(Megha -> 1, Ruchi -> 2)

aj. def take(n: Int): Map[A, B]

This returns the first n elements from the Map in Scala.

scala> m.take(2)
res98: scala.collection.immutable.Map[String,Int] = Map(Ayushi -> 0, Megha -> 1)

ak. def takeRight(n: Int): Map[A, B]

This returns the last n elements.

scala> m.takeRight(2)
res99: scala.collection.immutable.Map[String,Int] = Map(Megha -> 1, Ruchi -> 2)

al. def takeWhile(p: ((A, B)) => Boolean): Map[A, B]

This returns elements from the Map as long as the predicate is satisfied.

am. def toArray: Array[(A, B)]

This returns an Array from the Map.

scala> m.toArray
res100: Array[(String, Int)] = Array((Ayushi,0), (Megha,1), (Ruchi,2))

an. def toList: List[A]

This returns a List from the Map.

scala> m.toList
res101: List[(String, Int)] = List((Ayushi,0), (Megha,1), (Ruchi,2))

ao. def toSeq: Seq[A]

This returns a Sequence from the Scala Map.

scala> m.toSeq
res102: Seq[(String, Int)] = Vector((Ayushi,0), (Megha,1), (Ruchi,2))

ap. def toSet: Set[A]

This returns a Set from the Map.

scala> m.toSet
res103: scala.collection.immutable.Set[(String, Int)] = Set((Ayushi,0), (Megha,1), (Ruchi,2))

aq. def toString(): String

This returns a String from the Map.

scala> m.toString
res104: String = Map(Ayushi -> 0, Megha -> 1, Ruchi -> 2)

So, this was all on Scala Map. Hope you like our explanation,

Conclusion

A Map in Scala is a collection holding key-value pairs. In this tutorial, we saw how to create, process, and call methods on them.

For Reference

You give me 15 seconds I promise you best tutorials
Please share your happy experience on Google

follow dataflair on YouTube

Leave a Reply

Your email address will not be published. Required fields are marked *