Maps in scala

Sets in scala

Author: CodeLab20

Collections/Maps.scala

@@ -0,0 +1,68 @@
+/***
+    1. Maps store Key-Value Pairs
+    2. Internally maps are collection of tuples and can be operated as such
+    3. Symbols are like Strings but guaranteed to be Interned, perfect for Maps
+**/
+object Maps extends App
+{
+    //Map can be created using tuples
+    val m = Map.apply((1, "One"), (2, "Two"), (3, "Three"))
+    println("m : " + m)
+    val m2 = Map((1, "One"), (2, "Two"), (3, "Three"))
+    
+    //declaring tuple using -> operator
+    val tuple:(Int, String) = 3 -> "Three"
+    println(tuple)
+    
+    //declaring map using tuples with -> operator
+    val m3 = Map(1 -> "One", 2 -> "Two", 3 -> "Three")
+    println("m3 : " + m3)
+    
+    println(m3.get(1))      //Some("One"). get method returns option
+    println(m3.apply(1))    //"One"
+    println(m3(1))          //"One"
+    println(m3.get(4))      //None
+    //println(m3(4))          //throws NoSuchElementException
+
+    println("m3.toList : " + m3.toList)
+    println("m3.keys : " + m3.keys)
+    println("m3.keySet : " + m3.keySet)
+    println("m3.values.toSet : " + m3.values.toSet) //m3.values return MapLike.
+    
+    val m4 = Map("One"->1, "Two"->2, "Three"->3)
+    println("m4 : " + m4)
+    println("m4(\"Two\") : " + m4("Two"))
+
+    // we can use Also Symbol as a key inside Map
+    val sym = Symbol("Co")
+    val sym2 = 'Co
+    println("sym == sym2 :" + (sym == sym2))
+    println("sym eq sym2 :" + (sym eq sym2))
+    
+    val elements:Map[Symbol, String] = Map('Co -> "Cobalt", 'H -> "Hydrogen", 'Pb -> "Lead")
+    println("elements('Co) :" + elements('Co))
+ 
+    println("elements - 'H : " + elements - 'H)
+ 
+}
+
+/**
+Sample Output
+m : Map(1 -> One, 2 -> Two, 3 -> Three)
+(3,Three)
+m3 : Map(1 -> One, 2 -> Two, 3 -> Three)
+Some(One)
+One
+One
+None
+m3.toList : List((1,One), (2,Two), (3,Three))
+m3.keys : Set(1, 2, 3)
+m3.keySet : Set(1, 2, 3)
+m3.values.toSet : Set(One, Two, Three)
+m4 : Map(One -> 1, Two -> 2, Three -> 3)
+m4("Two") : 2
+sym == sym2 :true
+sym eq sym2 :true
+elements('Co) :Cobalt
+
+**/

Collections/Sets.scala

@@ -0,0 +1,60 @@
+/*
+    1. Set is a companion object.
+    2. Set is Immutable object with duplicates not allowed, searchable
+*/
+
+object Sets extends App
+{
+    val set = Set.apply(1,2,3,4)
+    val set2 = Set(1,2,3,4,5)      //You can not create a set using new because trait Set is abstract; cannot be instantiated
+    val set3 = Set(1,2,4,3,4,5)
+    val set4 = Set(1,2,3,4,5,6,6,7)
+    val set5 = Set(1,2) 
+    
+    println("set: " + set)
+    println("set2: " + set2)
+    println("set3: " + set3)
+    println("set4: " + set4)
+    
+    //Set Operations
+    println("set diff set4 : " + set.diff(set4))            //empty set
+    println("set4.diff(set) :" + set4.diff(set))            //Set(5,6,7)
+    println("set union set3 :" + set.union(set3))           //Set(1,2,3,4,5)
+    println("set intersect set3 : " + set.intersect(set3))  //Set(1,2,3,4)
+    println("set5 intersect set4 : " + set5.intersect(set4))//Set(1,2)
+
+    //Set Union using ++
+    println("set ++ set2 : " + (set ++ set2))    //Set(1,2,3,4,5)
+    
+    //Adding elements from another List to Set
+    println("set ++ List(15,19,20) : " + (set ++ List(15,19,20)))    //Set(1,2,3,4,15,19,20)
+    
+    println("set -- set5 : " + (set -- set5)) //Set subtraction
+    println("set - 3 : " + (set - 3))         //remove element 3 from set
+    
+    //Check if an element is present in set
+    println("set.apply(4) : " + set.apply(4))
+    println("set.apply(10) : " + set.apply(10))         //apply method is mapped to contains method in set
+    println("set.contains(10) : " + set.contains(10))
+}
+
+/**
+    Sample Output
+set: Set(1, 2, 3, 4)
+set2: Set(5, 1, 2, 3, 4)
+set3: Set(5, 1, 2, 3, 4)
+set4: Set(5, 1, 6, 2, 7, 3, 4)
+set diff set4 : Set()
+set4.diff(set) :Set(5, 6, 7)
+set union set3 :Set(5, 1, 2, 3, 4)
+set intersect set3 : Set(1, 2, 3, 4)
+set5 intersect set4 : Set(1, 2)
+set ++ set2 : Set(5, 1, 2, 3, 4)
+set ++ List(15,19,20) : Set(20, 1, 2, 3, 19, 4, 15)
+set -- set5 : Set(3, 4)
+set - 3 : Set(1, 2, 4)
+set.apply(4) : true
+set.apply(10) : false
+set.contains(10) : false
+
+**/