Scala

Scala Tutorial for BeginnersProgrammingKnowledge · Scala for beginnersScala TutorialRock the JVM · Scala at light speed, part 1A Sweet Beginner's Guide to Scala by Daniel CiocirlanFunc Prog Sweden · Beginner's guide to Scala

What Scala isSearch on YouTubeBookmarkSaved

Scala is an object-oriented and functional programming language. Martin Odersky designed it. It appeared for the Java platform in early 2004 and for the .NET framework in June 2004.

Scala runs on the JVM, so Java libraries work from Scala code. Spark itself is written in Scala. That is why this paper teaches Scala before Spark.

Where Scala is usedSearch on YouTubeBookmarkSaved

The slides name five use cases. Three are data processing with Apache Spark, web development with the Play Framework, and concurrent and parallel programming. The other two are robust backend systems and financial applications.

Frameworks and librariesSearch on YouTubeBookmarkSaved

IDEsSearch on YouTubeBookmarkSaved

The slides name four IDEs. IntelliJ IDEA has a Scala plugin. Visual Studio Code has Scala plugins. Eclipse uses the Scala IDE plugin. Atom uses Scala plugins.

The REPLSearch on YouTubeBookmarkSaved

The REPL (Read-Eval-Print Loop) is an interactive shell. You type a snippet and it runs at once. Start it in three steps.

1. Open a terminal.
2. Type scala and press Enter.
3. Type Scala code and press Enter to see the result at once.

The slide session uses Scala 3.3.1 on Java 21.0.1. Each result gets a name (res0, res1) and a type.

scala> println("Hello, tutorialspoint")
Hello, tutorialspoint
scala> 445
val res0: Int = 445
scala> 10/6
val res1: Int = 1

Scripts and setupSearch on YouTubeBookmarkSaved

You can write Scala scripts in files with the .scala extension. The slide file is ScalaExample.scala.

object ScalaExample {
  def main(args: Array[String]): Unit = {
    println("Hello Scala")
  }
}

scalac ScalaExample.scala
scala ScalaExample

Environment setupSearch on YouTubeBookmarkSaved

Step 1 is to verify Java. Run java --version on Windows or Linux. The slide outputs show Java 11 and Java 21. Scala needs a JDK first.

Step 2 is to install Scala. The slide commands use old installers:

java -jar scala-2.11.5-installer.jar

java -jar scala-2.9.0.1-installer.jar

The Linux installer prints a welcome message and unpacks one software package. Then verify the install:

scala -version
scala

The first command prints the runner version (3.3.1 on the slide). The second opens the REPL welcome text.

First programSearch on YouTubeBookmarkSaved

A Scala program runs in two modes: interactive mode and script mode. In interactive mode you type scala, then println("Hello, Scala!"); prints Hello, Scala!. In script mode you save this file as HelloWorld.scala:

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello, world!")
  }
}

Compile it with scalac HelloWorld.scala. Run it with scala HelloWorld.

Data typesSearch on YouTubeBookmarkSaved

Scala has all the same data types as Java. The slide table is:

VariablesSearch on YouTubeBookmarkSaved

A mutable variable uses var. You can change its value later. An immutable variable uses val. You cannot change it after creation.

var myVar: String = "Foo"
var data: Int = 100
data = 101

val myVal: String = "Foo"

Type inferenceSearch on YouTubeBookmarkSaved

Scala infers the type when you skip it:

var myVar = 10;
val myVal = "Hello, Scala!";

Here myVar becomes Int and myVal becomes String by default. Inference never changes mutability: var stays mutable and val stays fixed.

Multiple assignmentsSearch on YouTubeBookmarkSaved

A method or block can return a Tuple (a fixed group of objects with different types). You can assign the whole Tuple to val variables at once:

val (myVar1: Int, myVar2: String) = Pair(40, "Foo")

// or, with inference:
val (myVar1, myVar2) = Pair(40, "Foo")

Both forms give myVar1 = 40 and myVar2 = "Foo". The second form lets inference find the types. The slides use Pair(40, "Foo"). In Scala 2.13 and 3, write (40, "Foo") instead.

object Demo {
  def main(args: Array[String]): Unit = {
    var myVar: Int = 10;
    val myVal: String = "Hello Scala with datatype declaration.";
    var myVar1 = 20;
    val myVal1 = "Hello Scala new without datatype declaration.";
    println(myVar); println(myVal); println(myVar1); println(myVal1);
  }
}

scalac Demo.scala
scala Demo

10
Hello Scala with datatype declaration.
20
Hello Scala new without datatype declaration.

StringsSearch on YouTubeBookmarkSaved

Create a string with or without an explicit type:

var greeting = "Hello world!";

// or, with an explicit type:
var greeting: String = "Hello world!";

String lengthSearch on YouTubeBookmarkSaved

object Demo {
  def main(args: Array[String]): Unit = {
    var palindrome = "Dot saw I was Tod";
    var len = palindrome.length();
    println("String Length is : " + len);
  }
}

The output is String Length is : 17. The count is 17. "Dot" gives 3. Two words add spaces and reach 8. "I" reaches 10. "was" reaches 14. "Tod" reaches 17.

Concatenating stringsSearch on YouTubeBookmarkSaved

string1.concat(string2) returns a new string with string2 added at the end:

"My name is ".concat("Zara")

The + operator is more common:

"Hello," + " world" + "!"

Only "Hello," + " world" + "!" gives Hello, world!; the concat form gives My name is Zara. The slides also show these two string examples:

object Demo {
  def main(args: Array[String]): Unit = {
    var greeting: String = "Hello, world!";
    println(greeting);
  }
}

The output is Hello, world!. And:

object Demo {
  def main(args: Array[String]): Unit = {
    var str1 = "Dot saw I was ";
    var str2 = "Tod";
    println("Dot " + str1 + str2);
  }
}

The output is Dot Dot saw I was Tod.

ArraysSearch on YouTubeBookmarkSaved

Declare an array with a fixed size, or from values directly:

var z: Array[String] = new Array[String](3)

// or, with inference:
var z = new Array[String](3)

// or, from values directly:
var z = Array("Zara", "Nuha", "Ayan")

Assign by index. The index can be any expression that yields a whole number:

z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"

Here $4/2 = 2$, so the third line sets index 2. The array is ["Zara", "Nuha", "Ayan"].

Multidimensional arraysSearch on YouTubeBookmarkSaved

var myMatrix = Array.ofDim[Int](3, 3)

ofDim[Int](3, 3) makes a $3 \times 3$ integer matrix. The general forms are Array.ofDim[T](n1), Array.ofDim[T](n1, n2) and Array.ofDim[T](n1, n2, n3). You need import Array._ for ofDim. You can also nest literals: Array(Array(e1, ...), Array(e2, ...)).

import Array._
object Demo {
  def main(args: Array[String]): Unit = {
    var myMatrix = ofDim[Int](3, 3)
    for (i <- 0 to 2) {
      for (j <- 0 to 2) {
        myMatrix(i)(j) = j;
      }
    }
    for (i <- 0 to 2) {
      for (j <- 0 to 2) {
        print(" " + myMatrix(i)(j));
      }
      println();
    }
  }
}

 0 1 2
 0 1 2
 0 1 2

Processing arraysSearch on YouTubeBookmarkSaved

Use loop control structures because all elements share one type and the size is known.

var myList = Array(1.9, 2.9, 3.4, 3.5)
for (x <- myList) {
  println(x)
}
var total = 0.0;
for (i <- 0 to (myList.length - 1)) {
  total += myList(i);
}
println("Total is " + total);
var max = myList(0);
for (i <- 1 to (myList.length - 1)) {
  if (myList(i) > max) max = myList(i);
}
println("Max is " + max);

The slides link the full method list at https://www.tutorialspoint.com/scala/scala_arrays.htm.

OperatorsSearch on YouTubeBookmarkSaved

The slides name five groups: arithmetic, relational, logical, bitwise and assignment operators. The worked demo uses arithmetic with a = 10, b = 20, c = 25, d = 25.

println("a + b = " + (a + b));
println("a - b = " + (a - b));
println("a * b = " + (a * b));
println("b / a = " + (b / a));
println("b % a = " + (b % a));
println("c % a = " + (c % a));

If elseSearch on YouTubeBookmarkSaved

The syntax is:

if (Boolean_expression) {
  // Runs when the expression is true
} else {
  // Runs when the expression is false
}

object Demo {
  def main(args: Array[String]): Unit = {
    var x = 30;
    if (x < 20) {
      println("This is if statement");
    } else {
      println("This is else statement");
    }
  }
}

LoopsSearch on YouTubeBookmarkSaved

For loop with rangesSearch on YouTubeBookmarkSaved

for (a <- 1 to 10) {
  println("Value of a: " + a);
}

1 to 10 is an inclusive range. The output is ten lines: Value of a: 1 through Value of a: 10.

Multiple rangesSearch on YouTubeBookmarkSaved

Separate two ranges with a semicolon:

for (a <- 1 to 3; b <- 1 to 3) {
  println("Value of a: " + a);
  println("Value of b: " + b);
}

The outer variable a takes 1, 2, 3. The inner variable b takes 1, 2, 3 for each a. That is $3 \times 3 = 9$ pairs: (1,1), (1,2), (1,3), (2,1), (2,2), (2,3), (3,1), (3,2), (3,3). Each pair prints two lines, so 18 lines in all.

For loop with collectionsSearch on YouTubeBookmarkSaved

val numList = List(1, 2, 3, 4, 5, 6);
for (a <- numList) {
  println("Value of a: " + a);
}

The output is six lines: Value of a: 1 through Value of a: 6.

For loop with yieldSearch on YouTubeBookmarkSaved

yield builds a new collection from the loop instead of printing:

val numList = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
var retVal = for { a <- numList if a != 3; if a < 8 } yield a
for (a <- retVal) {
  println("Value of a: " + a);
}

With numList = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), the guards drop 3 and drop every value $\ge 8$. The result is List(1, 2, 4, 5, 6, 7). The second loop prints those six values, one per line.

Classes and objectsSearch on YouTubeBookmarkSaved

The slides cover five items: basic classes, anonymous objects, inheritance, implicit classes and singleton objects. The deck gives code for basic classes, anonymous objects and inheritance. It only names implicit classes and singleton objects. The outline also lists pattern matching, files I/O, closures and traits with no slides.

Basic classSearch on YouTubeBookmarkSaved

class Student {
  var id: Int = 0;
  var name: String = null;
}
object MainObject {
  def main(args: Array[String]): Unit = {
    var s = new Student()
    println(s.id + " " + s.name);
  }
}

The class sets var id: Int = 0 and var name: String = null explicitly, so it prints 0 null.

A class can take constructor parameters and define methods:

class Student(id: Int, name: String) {
  def getRecord(): Unit = {
    println(id + " " + name);
  }
}
object MainObject {
  def main(args: Array[String]): Unit = {
    var student1 = new Student(101, "Raju");
    var student2 = new Student(102, "Martin");
    student1.getRecord();
    student2.getRecord();
  }
}

The output is 101 Raju then 102 Martin.

The Point class shows mutable state with a move method:

import java.io._
class Point(val xc: Int, val yc: Int) {
  var x: Int = xc
  var y: Int = yc
  def move(dx: Int, dy: Int): Unit = {
    x = x + dx
    y = y + dy
    println("Point x location : " + x);
    println("Point y location : " + y);
  }
}
object Demo {
  def main(args: Array[String]): Unit = {
    val pt = new Point(10, 20);
    pt.move(10, 10);
  }
}

Start is (10, 20). Add (10, 10). The output is Point x location : 20 and Point y location : 30.

Anonymous objectSearch on YouTubeBookmarkSaved

An anonymous object has no reference name. Use it when you will not reuse it.

class Arithmetic {
  def add(a: Int, b: Int): Unit = {
    var add = a + b;
    println("sum = " + add);
  }
}
object MainObject {
  def main(args: Array[String]): Unit = {
    new Arithmetic().add(10, 10);
  }
}

new Arithmetic() creates the object and calls add at once. The output is sum = 20.

InheritanceSearch on YouTubeBookmarkSaved

Scala allows inheritance from one class only. Point is the superclass. Location is the subclass. Location adds a z coordinate and overrides the constructor values with override val.

val loc = new Location(10, 20, 15);
loc.move(10, 10, 5);

Point x location : 20
Point y location : 30
Point z location : 20

Access modifiersSearch on YouTubeBookmarkSaved

Members of packages, classes or objects can use private and protected. Without either keyword, access is public. The modifiers restrict which regions of code can reach the member.

class Outer {
  class Inner {
    private def f(): Unit = { println("f") }
    class InnerMost {
      f() // OK
    }
  }
  (new Inner).f() // Error: f is not accessible
}

package p {
  class Super {
    protected def f(): Unit = { println("f") }
  }
  class Sub extends Super {
    f()
  }
  class Other {
    (new Super).f() // Error: f is not accessible
  }
}

FunctionsSearch on YouTubeBookmarkSaved

A function declaration names the function, lists parameters and states the return type. A function definition adds the body:

object add {
  def addInt(a: Int, b: Int): Int = {
    var sum: Int = 0
    sum = a + b
    return sum
  }
}

A function that returns nothing returns Unit (like void in Java). Such functions are called procedures:

object Hello {
  def printMe(): Unit = {
    println("Hello, Scala!")
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    println("Returned Value : " + addInt(5, 7));
  }
  def addInt(a: Int, b: Int): Int = {
    var sum: Int = 0
    sum = a + b
    return sum
  }
}

CollectionsSearch on YouTubeBookmarkSaved

Scala has a rich collection library. Collections are containers of things. The containers can be sequenced, linear sets of items such as List, Tuple, Option and Map. A collection can hold any number of elements, or zero or one element (for example Option).

ListsSearch on YouTubeBookmarkSaved

Scala Lists resemble arrays: all elements share one type. Two differences matter. Lists are immutable, so assignment cannot change an element. Lists are linked lists, while arrays are flat. A list of type T is written List[T].

Build a list with List(...) or with :: (prepend) and Nil (empty list):

val fruit: List[String] = List("apples", "oranges", "pears")
val nums: List[Int] = List(1, 2, 3, 4)
val empty: List[Nothing] = List()
val dim: List[List[Int]] = List(List(1, 0, 0), List(0, 1, 0), List(0, 0, 1))

val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))
val empty = Nil

Key methods are head (first element), tail (all but first) and isEmpty.

println("Head of fruit : " + fruit.head)
println("Tail of fruit : " + fruit.tail)
println("Check if fruit is empty : " + fruit.isEmpty)
println("Check if nums is empty : " + nums.isEmpty)

Head of fruit : apples
Tail of fruit : List(oranges, pears)
Check if fruit is empty : false
Check if nums is empty : true

Concatenating listsSearch on YouTubeBookmarkSaved

Use the ::: operator, the ::: method or List.concat. All three join two or more lists.

var fruit = fruit1 ::: fruit2
println("fruit1 ::: fruit2 : " + fruit)
fruit = fruit1.:::(fruit2)
println("fruit1.:::(fruit2) : " + fruit)
fruit = List.concat(fruit1, fruit2)
println("List.concat(fruit1, fruit2) : " + fruit)

fruit1 ::: fruit2 : List(apples, oranges, pears, mangoes, banana)
fruit1.:::(fruit2) : List(mangoes, banana, apples, oranges, pears)
List.concat(fruit1, fruit2) : List(apples, oranges, pears, mangoes, banana)

SetsSearch on YouTubeBookmarkSaved

A Scala Set holds pairwise different elements of one type:

var s: Set[Int] = Set()
var s: Set[Int] = Set(1, 3, 5, 7)
var s = Set(1, 3, 5, 7)

MapsSearch on YouTubeBookmarkSaved

A Scala map holds key and value pairs. Any value is retrieved by its key. Keys are unique, but values need not be unique. Maps are also called hash tables. There are immutable and mutable kinds. An immutable object cannot change itself. By default Scala uses the immutable Map. For a mutable Map, import scala.collection.mutable.Map.

var A: Map[Char, Int] = Map()
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")
val nums: Map[Int, Int] = Map()

println("Keys in colors : " + colors.keys)
println("Values in colors : " + colors.values)
println("Check if colors is empty : " + colors.isEmpty)
println("Check if nums is empty : " + nums.isEmpty)

Keys in colors : Set(red, azure, peru)
Values in colors : MapLike(#FF0000, #F0FFFF, #CD853F)
Check if colors is empty : false
Check if nums is empty : true

Concatenate maps with ++ (operator or method). Duplicate keys collapse to one entry:

val colors1 = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
val colors2 = Map("blue" -> "#0033FF", "yellow" -> "#FFFF00")
var colors = colors1 ++ colors2
colors = colors1.++(colors2)

Print each key with its value:

colors.keys.foreach { i =>
  print("Key = " + i)
  println(" Value = " + colors(i))
}

The output is one line per pair: Key = red Value = #FF0000, then azure, then blue, then yellow.

TuplesSearch on YouTubeBookmarkSaved

A Scala Tuple combines a fixed number of items so they travel as a whole. Unlike an array or list, a Tuple can hold objects with different types. Tuples are immutable. Access elements with t._1, t._2 and so on. Iterate with t.productIterator().

val t = (1, "hello", Console)

// or, with explicit syntax:
val t = new Tuple3(1, "hello", Console)

The first line is short syntax for the second.

val t = (4, 3, 2, 1)
val sum = t._1 + t._2 + t._3 + t._4
println("Sum of elements: " + sum)

IteratorsSearch on YouTubeBookmarkSaved

An iterator is not a collection. It is a way to access the elements of a collection one by one. The two basic operations on an iterator it are next and hasNext. A call to it.next() returns the next element and advances the iterator state. it.hasNext tells whether more elements remain.

object Demo {
  def main(args: Array[String]): Unit = {
    val it = Iterator("a", "number", "of", "words")
    while (it.hasNext) {
      println(it.next())
    }
  }
}

Quick self-testSearch on YouTubeBookmarkSaved