Scala Intro

Scala Introduction

Learning Objectives

  • Provide more details of scala language

Basic Gramma

Start using Scala

After installed scala, you can type scala in command line and get result as follow:

$ scala
Welcome to Scala version 2.11.7
Type in expressions to have them evaluated.
Type :help for more information.

scala> println("Hello, World!")
Hello, World!

The synopsis of a varialbe is:

scala> val i:String = "abc"
i: String = abc
  • val means it it is immutable variable, you can use “var” to define a mutable variable
  • i is the name of this variable
  • String is the type of this string, it can be omitted here
  • “abc” is the value of this variable

Define a function:

scala> def foo(v0:Int, v1:Int):Int = {
     |     println(v0 max v1)
     |     v0 + v1
     | }
foo: (v0: Int, v1: Int)Int

scala> foo(1, 2)
2
res0: Int = 3

Define a class:

scala> class Foo(a:String, b:Int) {
     |     def length = a.length
     | }
defined class Foo

scala> val foo:Foo = new Foo("Hello, World!", 3)
foo: Foo = Foo@6438a396

scala> println(foo.length)
13

Define a case class:

scala> case class Foo(a:String, b:Int)
defined class Foo

scala> val foo:Foo = Foo(a = "Hello, World!", b = 3)
foo: Foo = Foo(Hello, World!,3)

scala> println(foo.a)
Hello, World!

Differences between case class and class

Define an Object

scala> object Foo {
     |     def greeting() {
     |         println("Greeting from Foo")
     |     }
     | }
defined object Foo

scala> Foo.greeting()
Greeting from Foo

Functions/variables in Object is similar to the static function and variable in Java.

What is ought to be highligted is the use of “apply”. SomeObject.apply(v:Int) equals SomeObject(v:Int)

scala> :paste
// Entering paste mode (ctrl-D to finish)

case class Foo(a:String, b:Int)
object Foo {
	def apply(a:String): Foo =
		Foo(a, a.length)
}

// Exiting paste mode, now interpreting.

defined class Foo
defined object Foo

scala> val foo = Foo("Hello, World!")
foo: Foo = Foo(Hello, World!,13)

Finally, we should know the usage of code block.

We can create a code block anywhere, and the last line is the result of this block.

For example,

def foo(i:Int) = {
	println(s"value: $i")
	i * 2
}

val newList = List[Int](1, 2, 3).map(i => foo(i))

We can use the follow lines instead:

val newList = List[Int](1, 2, 3).map(i => {
    println(s"value: $i")
	i * 2
})

A better practice here is:

val newList = List[Int](1, 2, 3).map{i =>
    println(s"value: $i")
	i * 2
}

Case Study of some Common Types

Option, Some, None

We can use null in Scala as null pointer, but it is not recommended. We are supposed to use Option[SomeType] to indicate this variable is optional.

We can assueme every variable without Option are not null pointer if we are not calling java code. This help us reduce a lot of code.

If we wanna to get a variable with Option, here are two method

val oi = Option(1)
val i = oi match {
	case Some(ri) => ri
	case None => -1
}
println(i)

Besides, we can also use method “isDefined/isEmpty”.

val oi = Option(1)
if(oi.isDefined) {
	println(s"oi: ${oi.get}")
} else {
	println("oi is empty")
}

What should be highlighted is Option(null) returns None, but Some(null) is Some(null) which is not equals None.

match is a useful reserved words, we can use it in various of situations

Firstly, we can use it as “switch” & “case” in some other programming languages.

true match {
    case true => println("true")
    case false => println("false")
}

Secondly, we can find it by the type of the data,

case class A(i:Int,j:Double)
case class B(a:A, k:Double)
val data = B(A(1,2.0),3.14)
data match {
    case B(A(_,v),_) =>
        println(s"required value: $v")
    case _ =>
        println("match failed")
}

Given a case class B, but we only wish to retrievee the value B.a.j, we can use “_” as placeholder.

Common methods in List, Array, Set, and so on

In scala, we always transfer the List( Array, Set, Map etc.) from one status to another status. the methods of

  • toList, toArray, toSet – convert each other

  • par – Parallelize List, Array and Map, the result of Seq[Int]().par is ParSeq[Int], you will able to process each element in parallel when you are using foreach, map etc., and unable to call “sort” before you are using “toList”.

  • distinct – Removes duplicate elements

  • foreach – Process each element and return nothing

List[Int](1,2,3).foreach{ i =>
	println(i)
}

It wil print 1, 2, 3 in order

List[Int](1,2,3).par.foreach{ i =>
	println(i)
}

It will print 1, 2, 3, but the order is not guaranteed.

  • map – Process each element and construct a List using return value
List[Int](1,2,3).map{ i => i + 1}

It will return List[Int](2,3,4)

The result of List[A]().map(some-oper-return-type-B) is List[B], while the result of Array[A]().map map is Array[B].

  • flatten – The flatten method takes a list of lists and flattens it out to a single list:
scala> List[List[Int]](List(1,2),List(3,4)).flatten
res1: List[Int] = List(1, 2, 3, 4)

scala> List[Option[Integer]](Some(1),Some[Integer](null),Some(2),None,Some(3)).flatten
res2: List[Integer] = List(1, null, 2, 3)

  • flatMap – The flatMap is similar to map, but it takes a function returning a list of elements as its right operand. It applies the function to each list element and returns the concatenation of all function results. The result equals to map + flatten

  • collect – The iterator obtained from applying the partial function to every element in it for which it is defined and collecting the results.

scala> List(1,2,3.4,"str") collect {
     |   case i:Int => (i * 2).toString
     |   case f:Double => f.toString
     | }
res0: List[String] = List(2, 4, 3.4)

The function match elements in Int and Double, process them and return the value, but ignore string elements.

  • filter – Filter this list
scala> List(1,2,3).filter(_ % 2 == 0)
res1: List[Int] = List(2)
  • filterNot – Similar to filter
scala> List(1,2,3).filterNot(_ % 2 == 0)
res2: List[Int] = List(1, 3)
  • forall – Return true if All elements are return true by the partial function. It will immediately return once one element returns false, and ignore the rest elements.
scala> List(2,1,0,-1).forall{ i =>
     |   val res = i > 0
     |   println(s"$i > 0? $res")
     |   res
     | }
2 > 0? true
1 > 0? true
0 > 0? false
res0: Boolean = false
  • exists – Return true if there are at least One element returns true.
scala> List(2,1,0,-1).exists{ i =>
     |   val res = i <= 0
     |   println(s"$i <= 0? $res")
     |   res
     | }
2 <= 0? false
1 <= 0? false
0 <= 0? true
res2: Boolean = true
  • find – Return the first element returns true by the partial function. Return None if no elemet found.
scala> List(2,1,0,-1).find{ i =>
     |   val res = i <= 0
     |   println(s"$i <= 0? $res")
     |   res
     | }
2 <= 0? false
1 <= 0? false
0 <= 0? true
res3: Option[Int] = Some(0)
  • sortWith – sort the elements
scala> List(1,3,2).sortWith((leftOne,rightOne) => leftOne > rightOne)
res5: List[Int] = List(3, 2, 1)
  • zipWithIndex –
List("a","b").zipWithIndex.foreach{ kv:(String,Int) => println(s"k:${kv._1}, v:${kv._2}")}

It will rebuild a List with index

k:a, v:0
k:b, v:1
  • for - Scala’s keyword for can be used in various of situations.

Basically,

for{
  i <- List(1,2,3)
} yield (i,i+1)

It equals:

List(1,2,3).map(i => (i, i+1))

Besides,

for{
  i <- List(1,2,3)
  j <- List(4,5,6)
} yield (i,j)

We will get the cartesian product of List(1,2,3) and List(4,5,6): List((1,4), (1,5), (1,6), (2,4), (2,5), (2,6), (3,4), (3,5), (3,6))

We can add a filter in condition:

for{
  i <- List(1,2,3)
  if i != 1
  j <- List(4,5,6)
  if i * j % 2 == 1
} yield (i,j)

the result is : List((3,5))

Another usage of for is as follow:

Let’s define variables as follow:

val a = Some(1)
val b = Some(2)
val c = Some(3)

We can execute like this:

for {
	i <- a
	j <- b
	k <- c
	r <- {
		println(s"i: $i, j:$j, k:$k")
		Some(i * j * k)
	}
} yield r

The response is:

i: 1, j:1, k:3
res9: Option[Int] = Some(6)

Let’s define b as None:

scala> val b:Option[Int] = None
b: Option[Int] = None

scala> for {
     |   i <- a
     |   j <- b
     |   k <- c
     |   r <- {
     |           println(s"i: $i, j:$j, k:$k")
     |           Some(i * j * k)
     |   }
     | } yield r
res14: Option[Int] = None
  • while - Similar to while in java
var i = 0
while ({
	i = i + 1
	i < 1000
}){
	// body of while
	println(s"i: $i")
}

  • to, until — (1 to 10) will generate a Seq, with the content of (1,2,3,4…10), (0 until 10) will generate a sequence from 0 to 9. With some test, (0 until 1000).map(xxx) appears to be slower than var i=0; while( i < 1000) { i += 1; sth. else}, but if the body of map is pretty heavy, this cost can be ignored.

  • headOption - Get the head of one list, return None if this list is empty

  • head - Get the head of one list, throw exception if this list is empty

  • take – Get first at most N elements. (from left to right)

scala> List(1,2,3).take(2)
res0: List[Int] = List(1, 2)

scala> List(1,2).take(3)
res1: List[Int] = List(1, 2)
  • drop – Drop first at most N elements.
scala> List(1,2,3).drop(2)
res2: List[Int] = List(3)

scala> List(1,2).drop(3)
res3: List[Int] = List()

dropRight will drop elements from right to left.

  • slice – Return list in [start-offset, end-offset)
scala> List(1,2,3).slice(1,2)
res7: List[Int] = List(2)

scala> List(1,2,3).slice(2,2)
res8: List[Int] = List()

val offset = 1
val size = 3
List(1,2,3,4,5).slice(offset, size + offset)

If the end-offset is greater than the length of this list, it will not throw exception.

  • splitAt – Split this list into two from offset i
scala> List(1,2,3).splitAt(1)
res10: (List[Int], List[Int]) = (List(1),List(2, 3))
  • groupBy – Partitions a list into a map of collections according to a discriminator function
scala> List(1,2,3).groupBy(i => if(i % 2 == 0) "even" else "odd" )
res11: scala.collection.immutable.Map[String,List[Int]] = Map(odd -> List(1, 3), even -> List(2))
  • partition – Splits a list into a pair of collections; one with elements that satisfy the predicate, the other with elements that do not, giving the pair of collections (xs filter p, xs.filterNot p).
scala> List(1,2,3).partition(_ % 2 == 0)
res12: (List[Int], List[Int]) = (List(2),List(1, 3))
  • grouped – The grouped method chunks its elements into increments.
scala> List(1,2,3,4,5).grouped(2)
res13: Iterator[List[Int]] = Iterator(List(1, 2), List(3, 4), List(5))

You can visit this PDF for an official guide.

We also highly recomended to read the book Programming in Scala for more detail instruction.