INTRODUCTION
Data Structure can be defined as the group of data elements that provides an efficient way of storing and organizing data in the computer so that it can be used efficiently. Some examples of Data Structures are arrays, Linked List, Stack, Queue, etc. The sets and maps are the most common topic in collections where can use so many places.scala’s collection framework provides two important interfaces: Sets and Maps. It is possible to store a collection of objects as a single unit using Set and Map interfaces. The main difference between Sets and Maps is that Set contains different elements, whereas Map contains the data in key-value pairs.
Introduction to Scala Collections
Basically, collections are containers of things. The collection classes can be found in the package scala. collection. Collections are of two types –
- Mutable Collections
- Immutable Collections
Mutable Collection –All classes in scala. collection. mutable package belongs to the Mutable collection type. . Mutable Collection be able to be changed following created
Immutable Collection – In Immutable Collection, It does not agree to change data. Scala imports this package by default. If you desire the mutable collection, you have to import scala.collection.mutable package in your code.
SET
A set is a collection of items that are unique. Each set is unique because of the == method it holds. If you add a duplicate item, set silently discards the request.
Syntax:
Mutable Set
var variable_name: Set[type] = Set(item1, item2, item3)
or
var variable_name = Set(item1, item2, item3)
Immutable set
val variable_name: Set[type] = Set(item1, item2, item3)
or
val variable_name = Set(item1, item2, item3)
Basic operations Of Sets:
HEAD: This method returns the first element of a set. If the set is empty, the method returns true, otherwise false.
TAIL: This method returns a set that contains all elements except the first.
IsEmpty: When this method returns true, the set is empty, else it returns false.
Setting up Scala in a way that works:
- There are two kinds of sets in Scala: mutable and immutable. A mutable set changes the value of the object, while an immutable set does not change the object’s value.
- As far as Scala is concerned, an immutable set is found under the Scala.collection.immutable._ package, while a mutable set is under the Scala.collection.mutable._ package.
- The Scala.collection.immutable._ package can be used to define mutable sets as well.
- It is possible to create an empty set in Scala.
- In Scala, immutable objects are the default.
EXAMPLE:
// use of immutable set
import scala.collection.immutable._
object Main
{
def main(args: Array[String])
{
// Creating and initializing immutable sets
val names: Set[String] = Set("Emily", "Smith",
"Johnsons", "Adler")
val age = Set("22", "23", "25", "21")
// Display the value of names
println("Name:"+names)
println("\nAge:"+age)
}
}
EXAMPLE:
import scala.collection.mutable._
object Fruits {
def main(args: Array[String])
{
// Creating and initializing mutable sets
val fruitsSet: Set[String] = Set("Apple", "Grapes", "Orange", "Peach")
val numbersSet = Set(1,2,3,4)
//Display the value of myset1
println("Set 1:"+fruitsSet)
// Display the value of myset2
println("\nSet 2:"+numbersSet)
}
Sorted Set
Sets store non-repeatable elements, and sort them in a set so that elements appear in a certain order. SortedSets guarantee the order of elements.
a sorted set is a trait that provides the Set semantics but also allows you to drive the ordering of the elements within the SortedSet.
Initiating a SortedSet with 3 elements:
import scala.collection.mutable.SortedSet
val Data: SortedSet[String] = SortedSet("Rex","cody","zack")
println(s"Elements of Data = $Data")How to add elements to SortedSet:
import scala.collection.mutable.SortedSet
Data += "Roy"
println(s"Elements = $Data")Map
There are two kinds of Maps: the immutable and the mutable. All values can be established by searching under a key in the Map. in general, Scala utilizes immutable Map class; we require to import the scala.collection.mutable.Map class to use mutable Map.
Syntax :
Mutable variable = scala.collection.mutable.Map(key_1 -> value_1, key_2 -> value_2, key_3 -> value_3) Immutable variable = Map(key_1 -> value_1, key_2 -> value_2, key_3 -> value_3)
Operations on a Scala Map
Using Scala Map, we can perform the following three basic operations:
- Keys – A scale map’s keys are returned as an iterablein this method.
- values -Scala map values can be obtained by using the Value method.
- Is Empty – Maps can be empty using the Scala isEmpty method that returns true if they are empty. Otherwise, they return false.
EXAMPLE:
object Main{
def main(args:Array[String])
{
val names = Map( 1->"Bob", 2->"Angelina" , 3->"Gwen" )
val matcher = names(1)
println(matcher)
}
}
Updating the values
In the case of immutable maps, Scala will output an error when you try to update values. However, mutable maps accept any changes that are made to key values.
Example:
object Main
{
def main(args:Array[String])
{
val Names = scala.collection.mutable.Map("Emily" -> 10,
"John" -> 20,
"Alisha" -> 30)
println("Before Updating: " + Names)
// Updating
Names("Emily") = 40
println("After Updating: " + Names)
}
}
Adding new key-value pair
An added or updated pair of keys can be inserted using the += operator in a mutable map.
Example:
object Main
{
def main(args:Array[String])
{
val Names = scala.collection.mutable.Map("Sam" -> 10,
"Tom" -> 20,
"Ali" -> 30)
println("Before Adding: "+Names)
//Adding a new key "Phils"
//updating an existing key "Sam"
Names += ("Phils" -> 100, "Sam" -> 40)
println("After Adding: "+Names)
}
}
Iteration in a Map
When performing an iteration loop, a variable should be a pair for key-value pairs.
EXAMPLE:
object Main
{
def main(args:Array[String])
{
val Names = scala.collection.mutable.Map("Harry" -> 10,
"Tom" -> 20,
"Elice" -> 30)
// (k, v) is a tuple with two elements
for((k, v) <- Names)
{
//where k is key and v is value
print("Key:"+k+", ")
println("Value:"+v)
}
}
}
Empty Map
It is also possible to create a Scala Map that is empty and fill it with elements later.
EXAMPLE:
object Main
{
def main(args:Array[String])
{
val Data = scala.collection.mutable.Map[String, Int]()
println("Empty: " + Data)
// Adding new entry
Data += ("Charlie" -> 50)
println("New Entry: " + Data)
}
}
Links:
https://docs.scala-lang.org/
https://www.tutorialspoint.com/scala/index.htm
