What is Scala | Methods to Call on a Map | Set-1?

In this article, we will learn Scala | Methods to Call on a Map | Set-1,This free Scala tutorial for complete beginners will help you learn Scala from scratch.

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

Output:

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

Output:

 Map()

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

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

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:

// 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) 
    } 
} 

Output:

(Rohit, 16)

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

// 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) 
    } 
} 

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.