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:

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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

    
    

    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.



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :

Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.