Scala | Methods to Call on a Map | Set-1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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.

Scala | Methods to Call on a Map | Set-1

Explore