Hi all,

In two previous posts, I have guided you to prepare the environment, install IDE, and some basic of Scala. You can refer to the first part here, or the second part here

Today, I write the second part of Scala, focus on Arrays, Lists, Maps And Classes

Please note that the original tutorials: http://scalatutorials.com

Arrays

Introduction

1. Arrays construct

   Array(element1, element2, ...)
   

2. You can declare type of Array like

   Array[Int]
   //or
   Array[String]
   

3. To print nicely an Array’s content

   array_name.mkString(",")
   

4. Arrays are mutable (can’t change it’s size once created, but can modify it’s elements)
5. Array elements can be of any type

       class Foo(val value1:Int)
       class Bar(value1:Int, val value2:Int) extends Foo(value1)
       val list:Array[Foo] = Array(new Foo(1), new Bar(2,3))
   

Practice

1. Write function that print Array elements

     def printArray(array:Array[Int]) = println(array.mkString("Array(" , ", " , ")"))
   
     // Mutable array of type Array[Int]
     val array1 = Array(1, 2, 3) 
     printArray(array1)//>Array(1, 2, 3)
   
     // Mutable array of type Array[String]  
     val array2 = Array("a", "b", "c")
     printArray(array2)
   
     // Mutable array of type Array[Any]
     val array3 = Array("a", 2, true)
     printArray(array3)
   

2. Array index

     val array4 = Array(1, 2, 3, 4, 5)
     println(array4(0))
   
     array4(0) = 6
     println(array4(0))
   
     println(array4.indexOf("3")) // -1
     println(array4.indexOf(3)) // 2
   

3. Concatenation

   // Concatenation using the ++ operator,   
   // Prepending items using +: and appending using :+    
     val concatenated = 1 +: (array1 ++ array4) :+ 2
     printArray(concatenated)
   

4. Diff

   val diffArray = Array(1,2,3,4).diff(Array(2,3))
   printArray(diffArray)
   

5. Contains

     val A = Array((1,2),(3,4))
     println(A contains (1,2))
   

And many, many other APi you can find on Scala site: http://www.scala-lang.org/api/current/index.html#scala.Array

List

Introduction

• Construct

  List(element1, element2, ...)
  

• List elements can be of any type

  class Foo(val value1:Int)
  class Bar(value1:Int, val value2:Int) extends Foo(value1)
  val list:List[Foo] = List(new Foo(1), new Bar(2,3))
  

• Reference: http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.List
• The default List is implemented as a Linked list
• It is immutable (any “changes” craete a new list, the original is untouched)

Practice

1. Declare Immutable List

   //Immutable list of type List[Int]  
   val list1 = List(1, 2, 3) // list1 = List(1, 2, 3)  
   //Immutable list of type List[Any]  
   val list2 = List("a", 2, true) // list2 = List(a, 2, true)  
   
   def printIntegerList(list:List[Int]) = println(list.mkString("List(" , ", " , ")"))
   printIntegerList(_list1)
   

2. Mutable list

   
     import collection.mutable
     //the "mutable version" of List
     val mlist = mutable.ArrayBuffer("a", "b", "c")
     def printStringList(list:mutable.ArrayBuffer[String]) = println(list.mkString("String List(" , ", " , ")"))
     printStringList(mlist)
   
   

3. Using (index)

   val firstItem = list1(0) // firstItem = 1  
   
   //Modify items the same way  (mutable Lists only)    
   mlist(0) = "d"    
   mlist
   

4. Concatenation

   // using the ++ operator or ::: (lists only)  
   list1 ++ list2 // List(1, 2, 3, a, 2, true)  
   list1 ::: list2 // List(1, 2, 3, a, 2, true)  
   
   //Prepending an item using either :: (lists only) or +:  
   0 :: list1 // List(0, 1, 2, 3)  
   0 +: list1 // List(0, 1, 2, 3)  
   
   //appending an item using :+ (not efficient for immutable List)  
   list1 :+ 4 // List(1, 2, 3, 4)  
   
   //all together  
   val concatenated = 1 :: list1 ::: list2 ++ mlist :+ 'd' // concatenated = List(1, 1, 2, 3, a, 2, true, d, b, c, d)  
   //concatenation doesn't modify the lists themselves     
   list1 // List(1, 2, 3) 
   

5. Access elements

   //Removing elements (mutable list only, creates a new array):  
   //creates a new array with "c" removed, mlist is not touched  
   mlist - "c" // ArrayBuffer(d, b)  
   //creates a new array with e, f removed, mlist is not touched  
   mlist -- List("e", "f") // ArrayBuffer(d, b, c)  
   //mlist not modified  
   mlist // ArrayBuffer(d, b, e, f, g)  
   //Removing elements (mutable Lists only):   
   
   //removes c from the list itself  
   mlist -= "c" // ArrayBuffer(d, b, e, f, g)  
   mlist // ArrayBuffer(d, b, e, f, g)  
   //removes e and f from mlist itself  
   mlist --= List("e", "f") // ArrayBuffer(d, b, e, f, g)  
   mlist // ArrayBuffer(d, b, e, f, g)  
   
   //Adding elements (mutable Lists only)   
   mlist += "e" // ArrayBuffer(d, b, e, f, g)  
   mlist ++= List("f", "g") // ArrayBuffer(d, b, e, f, g)  
   
   mlist //ArrayBuffer(d, b, e, f, g) // ArrayBuffer(d, b, e, f, g)  
   
   //Diff   
   val diffList = List(1,2,3,4) diff List(2,3) // diffList = List(1, 4) 
   

Maps

Introduction

• Maps are constructed simply using Map(key1 -> value1, key2 -> value2, …)
• The default Map is Predef.Map which points to scala.collection.immutable.Map
• You can’t have duplicate keys, adding a key value pair whose key already exists, overwrites the value
• Order of iteration is not guaranteed to be consistent

Practice

1. Immutable Construction

   val map1 = Map("one" -> 1, "two" -> 2, "three" -> 3)   
   //Map of type Map[String, Int]  
   val map2 = Map(1 -> "one", "2" -> 2.0, 3.0 -> false)   
   //Map of type Map[Any, Any]  
   

2. Mutable Construction

   import collection.mutable  
   val mmap = mutable.HashMap("a" -> 1, "b" -> 2 , "c" -> 3)   
   //the "mutable version" of Map  
   

3. Cannot duplicate key

   //Maps remove duplicate keys:  
   println(Map("a" -> 1, "a" -> 2)) //Map(a -> 2)  
   

4. Access Items

   val one = map1("one") 
   
   //NoSuchElementException will be thrown if key doesn't exist!  
   //e.g. this code: val fourExists = map1("four")   
   //throws NoSuchElementException: key not found: four  
   //the get method returns an Option, which will be explained later  
   val fourExistsOption = map1.get("four")  
   
   println(one) // 1  
   println(fourExistsOption.isDefined) // false  
   
   //You can set / modify items using map(key) = value  
   mmap("d") = 4   
   println(mmap) //Map(b -> 2, d -> 4, a -> 1, c -> 3) 
   
   
   //Removing elements (mutable Sets only)  
   mmap -= "c"  
   println (mmap) //Map(b -> 2, d -> 4, a -> 1)  
   
   //Adding elements (mutable Lists only)  
   mmap += "e" -> 5  
   mmap ++= Map("f" -> 6, "g" -> 7)  
    
   

5. Concatenation

   //Concatenation using the ++ operator   
   //(removes duplicate keys, order not guaranteed)  
   val concatenated = map1 ++ map2 ++ mmap  
   println(concatenated)   
   // Map(three -> 3, 1 -> one, two -> 2, a -> 1, b -> 2, 3.0 -> false, 2 -> 2.0, c -> 3, one -> 1, d -> 4)  
   //Concatenation doesn't modify the maps themselves   
   println(map1) //Map(one -> 1, two -> 2, three -> 3)  
   

6. Find elements

   //Find   
   val personMap = Map(("Alice",1), ("Bob",2), ("Carol",3))  
   def findByName(name:String) = personMap.getOrElse(name, 4)  
   val findBob = findByName("Bob")  
   val findEli = findByName("Eli")  
   
   println(findBob) //2  
   println(findEli) //4  
   

Classes

Introduction

• The class body, is also the default constructor’s implementation
• Automatic getters are generated for the class parameters defined using val

  class Person(val name:String) //generates a private `name` variable, and a getter with the same name  
  

• Automatic getters and setters are generated for class parameters defined using var

  class Person(var name:String) //generates a private name variable, a getter and a setter with the same name 
  

• Everything is public by default unless explicity declared otherwise

Practice

//Simple class that does nothing   
class Person(fname:String, lname:String)  
val p1 = new Person("Alice", "In Chains")  
//p1.fname / lname is not accessible  

//A class with a method  
class Person2(fname:String, lname:String){  
  def greet = s"Hi $fname $lname!"  
}  
val p2 = new Person2("Bob", "Marley")  
println(p2.greet)  
//p2.fname / lname is not accessible  

//A class with a public read only variable   
class Person3(fname:String, lname:String){  
  // a public read only field   
  val fullName = s"$fname $lname"   
  def greet = s"Hi $fullName!"  
}  

val p3 = new Person3("Carlos", "Santana")  
println(p3.greet)  
println(p3.fullName)   
//p3.fname / lname is not accessible  

//auto creates a getter for fname, and getter + setter to lname  
class Person4(val fname:String, var lname:String)  

val p4 = new Person4("Dave", "Matthews") {  
  //override the default string representation   
  override def toString = s"$fname $lname"   
}  
println(p4.fname)  
println(p4.lname)  
//lname is defined as var, so it has a setter too  
p4.lname = "Grohl"  
println(p4)