Tag: Scala Cheat Sheet

The data types that are available in Scala as shown in the below table:

Variable Data Types

val or val VariableName : DataType = [Initial Value]

If you do not assign any initial value to a variable, then it is valid as follows

var myVar :Int; 
val myVal :String;

Multiple assignments

val (myVar1: Int, myVar2: String) = Pair(80, "Ahi")

Another way of defining variable:

val (myVar1, myVar2) = Pair(80, "Ahi")

Declaration of Package

package package_name
// Scala classes
// traits
// objects..

Chained methods

package x.y.z
// members of z

Or

package x
package y
package z
// member of z

Nesting packages

package x{
   // members of x {as required}
   package y{
      // members of y{as required}
      package z{
         // members of z{as required}
      }
   }
}

Adding Members to Packages

// file named as faculty.scala
package college
class faculty{
   def faculymethod(){}
}

Wildcard import

import scala.collection._

Selective import

import scala.collection.Vector
Or
import scala.collection.{Vector, Sequence}

Renaming import

import scala.collection.{Vector => Vec14}

Import all from java.util except Date

import java.util.{Date => _, _}

Use case in function args for pattern matching:

(xs zip ys) map { 
   case (x, y) => x * y 
}

`v42` with backticks is interpreted as the existing val v42, and “Not 42” is printed:

val v42 = 42 
3 match { 
   case `v42` => println("42") 
   case _ => println("Not 42") 
}

UppercaseVal is treated as an existing val, rather than a new pattern variable, because it starts with an uppercase letter. Thus, the value contained within UppercaseVal is checked against 3, and “Not 42” is printed:

val UppercaseVal = 42 
3 match { 
   case UppercaseVal => println("42") 
   case _ => println("Not 42") 
}

Classes

Basic Syntax:

class Class_name{
// methods and feilds
}

Some optional attributes:

• Keyword class: A class keyword is used to declare the type of class.
• Class name: The name should begin with an initial letter (capitalized by convention).
• Superclass(if any): The name of the class’s parent (superclass), if any, preceded by the keyword extends. A class can only extend (subclass) one parent.
• Traits(if any): A comma-separated list of traits implemented by the class, if any, preceded by the keyword extends. A class can implement more than one trait.
• Body: The class body is surrounded by { } (curly braces).

Object

An object consists of :

• State: It is represented by attributes of an object. It also reflects the properties of an object.
• Behavior: It is represented by methods of an object. It also reflects the response of an object with other objects.
• Identity: It gives a unique name to an object and enables one object to interact with other objects.

In Scala, an object of a class is created using the new keyword. The syntax of creating an object in Scala is:

var obj = new Objectname();

Object orientation

Three types of access modifiers available in Scala:

Arithmetic Operators

Relational Operators

Logical Operators

Assignment Operators

Bitwise Operators

Bitwise operator works on bits and performs bit by bit operation. Below is the truth tables for &, |, and ^

The Bitwise operators supported by Scala language is listed in the following table. Assume variable A holds 60 and variable B holds 13

Operators Precedence

if Statement

if(Boolean_expression) {
   // Statements will execute if the Boolean expression is true
}

if-else Statement

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

if-else-if-else Statement

if(Boolean_expression 1){
   //Executes when the Boolean expression 1 is true
} else if(Boolean_expression 2){
   //Executes when the Boolean expression 2 is true
} else if(Boolean_expression 3){
   //Executes when the Boolean expression 3 is true
} else {
   //Executes when the none of the above condition is true.
}

Nested if-else Statement

if(Boolean_expression 1){
   //Executes when the Boolean expression 1 is true
   if(Boolean_expression 2){
      //Executes when the Boolean expression 2 is true
   }
}

while Loop

while (condition)
{
    // Code to be executed
}

do..while Loop

do {
// statements to be Executed
} while(condition);

for Loop

for( var x <- Range ){
   statement(s);
}

break Statement

// import following package
import scala.util.control._
// create a Breaks object as follows
val loop = new Breaks;
// Keep the loop inside breakable as follows
loop.breakable {
   // Loop will go here
   for(...){
      ....
      // Break will go here
      loop.break;
   }
}

Or

import scala.util.control.Breaks._
breakable 
{
 for(..)
{
 code..
 break
}
}

Function Declarations

def functionName ([list of parameters]) : [return type]

Function Definitions

def functionName ([list of parameters]) : [return type] = {
   function body
   return [expr]
}

Calling Functions

functionName( list of parameters )

In the Second way, a user can also call the function with the help of the instance and dot notation as follows:

[instance].function_name(paramter_list)

Functions Call-by-Name

def callByValue(x: Int)

Nested Functions

def FunctionName1( perameter1, peramete2, ..) = {
def FunctionName2() = {
// code
}
}

Partially Applied Functions

val multiply = (a: Int, b: Int, c: Int) => a * b * c
// less arguments passed
val f = multiply(1, 2, _: Int)

Named Arguments

Function Definition : def createArray(length:int, capacity:int);
Function calling : createArray(capacity=20, length:10);

Recursion Functions

Example:

// Scala program of factorial using recursion
// Creating object
object sample
{
   // Function define
   def fact(n:Int): Int=
   {
      if(n == 1) 1
      else n * fact(n - 1)
   }
   // Main method
   def main(args:Array[String])
   {
      println(fact(3))
   }
}

=> Output

6

Higher-Order Functions

Example:

object Demo {
   def main(args: Array[String]) {
      println( apply( layout, 10) )
   }
   def apply(f: Int => String, v: Int) = f(v)
   def layout[A](x: A) = x.toString()
}

=> Output

10

Anonymous Functions

(z:Int, y:Int)=> z*y
Or
(_:Int)*(_Int)

Currying Functions

def function name(argument1, argument2) = operation

Creating a String

var str = "Hello world!";
or
var str:String = "Hello world!";

Note: If you need to append to the original string, then use StringBuilder class.

Get length of the string

var len = str.length();

Concatenating strings in Scala

The String class includes a method for concatenating two strings −

str1.concat(string2);

Or

Strings are more commonly concatenated with the + operator:

"My name is:" + " John" + "!"

Creating format string

Example:

// Scala program to illustrate how to
// Creating format string
object Main
{
   // two strings 
   var stringVar = "Hello world!"
   var intVar = 14
   var floatVar = 14.07
   // Main function 
   def main(args: Array[String]) 
   { 
       // using format() function 
       println("%s, %d, %f".format(stringVar, intVar, floatVar)); 
   } 
}

=> Output

Hello world!, 14, 14.07

Important string functions

One Dimensional Array

This array contains only one row for storing the values. All values of this array are stored contiguously starting from 0 to the array size.

Syntax:

var arrayname = new Array[datatype](size)

Multidimensional Arrays

Multidimensional arrays contain more than one row to store the values. Scala has a method Array.ofDim to create Multidimensional arrays in Scala.

Syntax:

var array_name = Array.ofDim[ArrayType](N, M)
 or  
var array_name = Array(Array(elements), Array(elements)

Here N is number of rows and M is number of Columns.

Scala Array Methods

Lists

Scala’s List[T] is a linked list of type T.

Below is an example of lists defined for various data types:

// List of Strings
val fruit: List[String] = List("bananas", "watermelons", "apples")
// List of Integers
val nums: List[Int] = List(1, 2, 3, 4)
// Empty List.
val empty: List[Nothing] = List()
// Two dimensional list
val dim: List[List[Int]] =
   List(
      List(1, 0, 0),
      List(0, 1, 0),
      List(0, 0, 1)
   )

Sets

A set is a collection of pairwise different elements of the same type.

Syntax:

// Empty set of integer type
var s : Set[Int] = Set()
// Set of integer type
var s : Set[Int] = Set(2,4,6,8)
or 
var s = Set(2,4,6,8)

Maps

A Map is a collection of key/value pairs. Any value can be retrieved based on its key.

Example

// Empty hash table whose keys are strings and values are integers:
var A:Map[Char,Int] = Map()
// A map with keys and values.
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

Tuples

Unlike an array or list, a tuple can hold objects with different types.

Example:

object Demo {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
      val sum = t._1 + t._2 + t._3 + t._4
      println( "Sum of elements: "  + sum )
   }
}

Iterators

An iterator is not a collection, but rather a way to access the elements of a collection one by one.

Example:

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