Prerequisite- Scala Map.

In Scala there are foremost Methods to call on a Map. A Scala Method is a section of a class which has a designation, a signature, optionally a few annotations, and whatsoever byte-code. A function which is interpreted as a member of some Object is termed as a Method and the Map Method is exactly incorporated with Collections furthermore it is a member of a Traversable trait which is executed by the Collection Classes of Scala (Traversable explicates numerous concrete Methods).

The most predominant Methods to call on a Scala Map are as follows:

• def ++(xs: Map[(A, B)]): Map[A, B]
  This Method is utilized to Concatenate two or more Maps. In Concatenating Maps it will separate the identical keys.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to concatenate two Map    // Creating Object object GFG  {     // Main method     def main(args: Array[String])      {            // Creating maps         val group1 = Map("Nidhi" -> 23, "Rahul" -> 18)         val group2 = Map("Geeta" -> 22, "Rahul" -> 18)            // using ++ as a method         val concatenate = group1.++(group2)            // Displays concatenated map         println( "Concatenation is: " + concatenate)     } }

  chevron_right

  filter_none

  Output:

  
  

  
  

  Concatenation is: Map(Nidhi -> 23, Rahul -> 18, Geeta -> 22)
  

  Here, the key “Rahul” is present in both the Map, so while Concatenating two Map, the similar one is removed.

• def -(elem1: A, elem2: A, elems: A*): Map[A, B]
  This method is utilized to delete the set of keys present in the arguments. So, it returns a new map containing all the elements of this Map except these arguments.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to delete keys    // Creating object object GFG {            // Main method     def main(args: Array[String])      {            // Creating mutable map          val m = scala.collection.mutable.Map[String, Int]("Geeta" -> 21, "Nidhi" -> 23)                 // using <b>-</b> as a method         val c = m.-("Geeta")            // Displays a new map         println( "The new Map returns: " + c)     } }

  chevron_right

  filter_none

  Output:

  The new Map returns: Map(Nidhi -> 23)
  

  Thus, the new map contains only “Nidhi” and “Geeta” is deleted.

• def get(key: A): Option[B]
  This method is utilized to return the keys corresponding to the values given in the method as argument.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to get values // corresponding to the key    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Rahul" -> 18)         val n = Map("Geeta" -> 22, "Rahul" -> 18)            // using 'get' as a method         val x = m.get("Rahul")         val y = n.get("Nidhi")            // Displays key corresponding          // to the given values          println(x)         println(y)     } }

  chevron_right

  filter_none

  Output:

  Some(18)
  None
  

  Here, “Rahul” returns the its corresponding value but “Nidhi” returns None, as this key is not related to the Map given.

• def iterator: Iterator[(A, B)]
  This method is utilized to return an iterator.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to return // an iterator    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Rahul" -> 18)         val n = Map("sonu" -> 16, "Nisha" -> 21)            // using 'iterator' as a method         val x = m.iterator         val y = n.iterator            // Displays if the iterator         // is empty or not         println(x)         println(y)     } }

  chevron_right

  filter_none

  Output:

  non-empty iterator
  non-empty iterator
  

  Here, both the Maps are non-empty so, non-empty iterator is returned.

• def addString(b: StringBuilder): StringBuilder
  This method is utilized to add each of the elements of the Map to the StringBuilder.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to add the elements // of Map to the StringBuilder    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Nisha" -> 21)         val n = Map("sonu" -> 16, "Rahul" -> 18)            // using 'addString' as a method         val x = m.addString(new StringBuilder())         val y = n.addString(new StringBuilder())               // Displays elements in the         // StringBuilder         println(x)         println(y)     } }

  chevron_right

  filter_none

  Output:

  
  

  
  

  Nidhi -> 23Nisha -> 21
  sonu -> 16Rahul -> 18
  

  Thus, the elements are returned in the StringBuilder.

• def addString(b: StringBuilder, sep: String): StringBuilder
  This method adds elements of the Map to the StringBuilder and also adds a separator between the elements.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to add the elements // of Map to the StringBuilder and  // also add a separator    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Nisha" -> 21)         val n = Map("sonu" -> 16, "Rahul" -> 18)            // using 'addString' as a method         // and adding a separator to it         val x = m.addString(new StringBuilder(), "_")         val y = n.addString(new StringBuilder(), "_")            // Displays elements in the         // StringBuilder with the          // separator         println(x)         println(y)     } }

  chevron_right

  filter_none

  Output:

  Nidhi -> 23_Nisha -> 21
  sonu -> 16_Rahul -> 18
  

  Thus, the elements are returned in the StringBuilder with a separator.

• def apply(key: A): B
  It is helpful in searching a key in the Map.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to search  // a key value    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Nisha" -> 21)         val n = Map("sonu" -> 16, "Rahul" -> 18)            // using 'apply' method         val x = m.apply("Nisha")         val y = n.apply("sonu")            // Displays values of          // the key          println(x)         println(y)     } }

  chevron_right

  filter_none

  Output:

  21
  16
  

  Here, if the searched key does not exists then the key value is not found.

• def clear(): Unit
  This is utilized to clear the Map.
  Note:value clear is a member of scala.collection.mutable.Map[String, Int].
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to clear // the Map    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating mutable map         val n = scala.collection.mutable.Map("Nidhi" -> 23,                                              "Nisha" -> 21)            // using 'clear' method         val x = n.clear()            //Displays empty Map          println(x)     } }

  chevron_right

  filter_none

  Output:

  ()
  

  Here, keys of a mutable Map are removed.

• def clone(): Map[A, B]
  This method is utilized to make a copy of the receivers object.
  Note:value clone is a member of scala.collection.mutable.Map[String, Int].
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to make // a copy of the receivers  // object    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating mutable map         val n = scala.collection.mutable.Map("Nidhi" -> 23,                                         "Nisha" -> 21)            // using 'clone' method         val x = n.clone()            // Displays copied keys         println(x)     } }

  chevron_right

  filter_none

  Output:

  Map(Nidhi -> 23, Nisha -> 21)
  

  Here, copy of the receivers object is returned.

• def contains(key: A): Boolean
  This method is utilized to check if the key is present in the Map or not. If the key is present it returns true else returns false.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to check if  // the key is present or not    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Rahul" -> 18)         val n = Map("sonu" -> 16, "Nisha" -> 21)            // using 'contains' method         val x = m.contains("Nidhi")         val y = n.contains("Rahul")            // Displays true if the key          // is present else false         println(x)         println(y)     } }

  chevron_right

  filter_none

  Output:

  
  

  
  

  true
  false
  

  Here, “Nidhi” is present in the Map so, true is returned but “Rahul” is not present in the given map so, it returns false.

• def copyToArray(xs: Array[(A, B)]): Unit
  This method is helpful in copying pair of keys of the Map to an Array.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to copy keys  // to an Array    // Creating object object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18)            // Creating Array         val x: Array[Any] = Array(0, 0, 0, 0, 0)            // using 'copyToArray' method         m.copyToArray(x)            // Displays keys copied in         // the Array         for(m1 <-x)             println(m1)     } }

  chevron_right

  filter_none

  Output:

  (Nidhi,23)
  (Rahul,18)
  0
  0
  0
  

  Here, two keys of the Map are copied to the Array.

• def count(p: ((A, B)) => Boolean): Int
  This method is utilized to count pair of keys in the Map.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to count // pair of keys in the Map    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18)            // using 'count' method         val y = m.count(z=>true)            // Displays number of keys         // in the Map         println(y)     } }

  chevron_right

  filter_none

  Output:

  2
  

  Here, two keys are present in the Map so, two is returned.

• def drop(n: Int): Map[A, B]
  This method is utilized to delete the first ‘n’ elements.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to delete // first n elements    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18,                     "Nisha" -> 21, "Rohit" -> 16)            // using 'drop' method         val y = m.drop(2)            // Displays all the elements of          // the map except the first two         // elements         println(y)     } }

  chevron_right

  filter_none

  Output:

  Map(Nisha -> 21, Rohit -> 16)
  

  Here, drop(n) is the desired operation, where first ‘n’ elements are deleted and rest of the elements are returned.

• def dropRight(n: Int): Map[A, B]
  This method is utilized to delete the last ‘n’ elements.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to delete  // last n elements    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18,                      "Nisha" -> 21, "Rohit" -> 16)            // using 'dropRight' method         val y = m.dropRight(2)            // Displays all the keys of          // map except the last two         // elements         println(y)     } }

  chevron_right

  filter_none

  Output:

   Map("Nidhi" -> 23, "Rahul" -> 18)
  

  Here, dropRight(n) is the desired operation, where last ‘n’ elements are deleted and rest of the elements are returned.

• def dropWhile(p: ((A, B)) => Boolean): Map[A, B]
  This operation deletes the elements until the stated condition is satisfied.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to delete the // elements until the stated // condition is satisfied    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18,                     "Nisha" -> 21, "Rohit" -> 16)            // using 'dropWhile' method         val y = m.dropWhile(z=>true)            // Displays empty map         println(y)     } }

  chevron_right

  filter_none

  Output:

   Map()
  

  Here, dropWhile is the desired operation and according to the given condition, an empty Map is returned.

• def empty: Map[A, B]
  This method is utilized to return an empty Map.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to form // an empty Map    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18,                     "Nisha" -> 21, "Rohit" -> 16)            // using 'empty' method         val y = m.empty            // Displays empty map         println(y)     } }

  chevron_right

  filter_none

  Output:

   Map()
  

• def equals(that: Any): Boolean
  This method is utilized to check if the two maps have the same key-values pair.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to check if the // two maps have the same  // number of elements       // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Rahul" -> 18)         val n = Map("Nisha" -> 21, "Rohit" -> 16)            // using 'equals' method         val y = m.equals(n)            // Displays true if the maps are         // equal else returns false         println(y)     } }

  chevron_right

  filter_none

  Output:

   false
  

  Here, equals method returns true if the key-value pairs of both the Maps are same else returns false.

• def init: Map[A, B]
  This method is utilized to return all the elements of the Map except the last one.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to return // all the elements of the // map except the last one    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18,                     "Nisha" -> 21, "Rohit" -> 16)            // using 'init' method         val y = m.init            // Displays all the elements         // except the last one         println(y)     } }

  chevron_right

  filter_none

  Output:

   Map(Nidhi -> 23, Rahul -> 18, Nisha -> 21)
  

  Here, out of four elements of the Map, the first three elements of the Map are returned.

• def last: (A, B)
  This method returns the last element of the Map.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to find the  // last element       // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18,                     "Nisha" -> 21, "Rohit" -> 16)            // using 'last' method         val y = m.last            // Displays the last element         println(y)     } }

  chevron_right

  filter_none

  Output:

  (Rohit, 16)
  

• def remove(key: A): Option[B]
  This method drops the key and return its value only.
  Example:
  filter_none

  edit
  close

  play_arrow

  link
  brightness_4
  code

  // Scala program to return the // value of the given key       // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating mutable map         val m = scala.collection.mutable.Map("Nidhi" -> 23,                 "Rahul" -> 18, "Nisha" -> 21, "Rohit" -> 16)            // using 'remove' method         val y = m.remove("Rahul")            // Displays the value associated         // with the key in the argument         println(y)     } }

  chevron_right

  filter_none

  Output:

  some(18)
  

  Note:The value remove is member of the mutable Map.
  These were the major methods of Scala, there are many more such methods.