Easwari Engineering College

191AIC302T-Object Oriented Programming with SCALA

Unit-I

UNIT I: Basics of Scala 9

Introduction - The Scala Environment – Data types – Variables – Operators - Expressions,
Values, and Types – Names – Classes and objects - Control statements and Looping Statements
– Strings – Arrays – Functions - Higher-Order Functions - Curried Functions - Higher-Order
Functions on Lists – Closures.

1.1 Introduction:

 Scala is a general-purpose programming language. It supports object oriented, functional

and imperative programming approaches. It is a strong static type language. In scala,
everything is an object whether it is a function or a number. It does not have concept of
primitive data.
 It was designed by Martin Odersky. It was officially released for java platform in early
2004 and for .Net framework in June 2004. Later on, Scala dropped .Net support in 2012.
 Scala is influenced by Java, Haskell, Lisp, Pizza etc. and influenced to F#, Fantom, Red
etc.
 File extension of scala source file may be either .scala or .sc.
 Applications like web application, enterprise application, mobile application, desktop
based application etc.

Features of Scala

There are following features of scala:

o Type inference
o Singleton object
o Immutability
o Lazy computation
o Case classes and Pattern matching
o Concurrency control
o String interpolation
o Higher order function
o Traits
o Rich collection set

Department of AI & DSPage 1

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Type Inference

In Scala, you don't require to mention data type and function return type explicitly. Scala is
enough smart to deduce the type of data. The return type of function is determined by the type of
last expression present in the function.

Singleton object

In Scala, there are no static variables or methods. Scala uses singleton object, which is essentially
class with only one object in the source file. Singleton object is declared by using object instead
of class keyword.

Immutability

Scala uses immutability concept. Each declared variable is immutable by default.

Immutable means you can't modify its value. You can also create mutable variables
which can be changed.Immutable data helps to manage concurrency control which
requires managing data.

Lazy Computation

In Scala, computation is lazy by default. Scala evaluates expressions only when they are
required. You can declare a lazy variable by using lazy keyword. It is used to increase
performance.

Case classes and Pattern matching

 Scala case classes are just regular classes which are immutable by default and
decomposable through pattern matching.
 All the parameters listed in the case class are public and immutable by default.
 Case classes support pattern matching. So, you can write more logical code.

Concurrency control

Scala provides standard library which includes the actor model. You can write
concurrency code by using actor. Scala provides one more platform and tool to deal with

Department of AI & DSPage 2

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

concurrency known as Akka. Akka is a separate open source framework that provides
actor-based concurrency. Akka actors may be distributed or combined with software
transactional memory.

String Interpolation

Since Scala 2.10.0, Scala offers a new mechanism to create strings from your data. It is
called string interpolation. String interpolation allows users to embed variable references
directly in processed string literals. Scala provides three string interpolation methods: s, f
and raw.

Higher Order Functions

 Higher order function is a function that either takes a function as argument or

returns a function. In other words, we can say a function which works with
another function is called higher order function.
 Higher order function allows you to create function composition, lambda function
or anonymous function etc.

Traits

 A trait is like an interface with a partial implementation. In Scala, trait is a

collection of abstract and non-abstract methods. You can create trait that can have
all abstract methods or some abstract and some non-abstract methods.
 Traits are compiled into Java interfaces with corresponding implementation
classes that hold any methods implemented in the traits.

Rich Set of Collection

 Scala provides rich set of collection library. It contains classes and traits to collect
data. These collections can be mutable or immutable. You can use it according to
your requirement. Scala.collection.mutable package contains all the mutable
collections. You can add, remove and update data while using this package.
 Scala.collection.immutable package contains all the immutable collections. It
does not allow you to modify data.

Department of AI & DSPage 3

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

1.2 The Scala Environment

Scala can be installed on any UNIX flavored or Windows based system. Before you start
installing Scala on your machine, you must have Java 1.8 or greater installed on your computer.
Follow the steps given below to install Scala.
Step 1: Verify Your Java Installation
First of all, you need to have Java Software Development Kit (SDK) installed on your system.
To verify this, execute any of the following two commands depending on the platform you are
working on.
If the Java installation has been done properly, then it will display the current version and
specification of your Java installation. A sample output is given in the following table.

Platform Command Sample Output

Java version "1.8.0_31"

Open Command Console Java (TM) SE Run Time

Windows and type − Environment (build 1.8.0_31-b31)
\>java –version Java Hotspot (TM) 64-bit Server
VM (build 25.31-b07, mixed mode)

Java version "1.8.0_31"

Open Command terminal Open JDK Runtime Environment (rhel-
Linux and type − 2.8.10.4.el6_4-x86_64)
$java –version Open JDK 64-Bit Server VM (build 25.31-b07,
mixed mode)

We assume that the readers of this tutorial have Java SDK version 1.8.0_31 installed on their
system.
In case you do not have Java SDK, download its current version
fromhttp://www.oracle.com/technetwork/java/javase/downloads/index.html and install it.
Step 2: Set Your Java Environment

Department of AI & DSPage 4

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Set the environment variable JAVA_HOME to point to the base directory location where Java
is installed on your machine. For example,

Sr.No Platform & Description

1 Windows
Set JAVA_HOME to C:\ProgramFiles\java\jdk1.7.0_60

2 Linux
Export JAVA_HOME=/usr/local/java-current

Append the full path of Java compiler location to the System Path.

Sr.No Platform & Description

Windows
1
Append the String "C:\Program Files\Java\jdk1.7.0_60\bin" to the end of the
system variable PATH.

2 Linux
Export PATH=$PATH:$JAVA_HOME/bin/

Execute the command java -version from the command prompt as explained above.
Step 3: Install Scala
You can download Scala from http://www.scala-lang.org/downloads. At the time of writing this
tutorial, I downloaded ‘scala-2.11.5-installer.jar’. Make sure you have admin privilege to
proceed. Now, execute the following command at the command prompt −

Platform Command & Output Description

Windows \>java –jar scala-2.11.5- This command will display an installation

installer.jar\> wizard, which will guide you to install
Scala on your windows machine. During
installation, it will ask for license

Department of AI & DSPage 5

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

agreement, simply accept it and further it

will ask a path where Scala will be
installed. I selected default given
path “C:\Program Files\Scala”, you can
select a suitable path as per your
convenience.

Command −
$java –jar scala-2.9.0.1-
installer.jar
Output −
Welcome to the installation of
Scala 2.9.0.1!
The homepage is at During installation, it will ask for license
−http://Scala-lang.org/ agreement, to accept it type 1 and it will
Linux ask a path where Scala will be installed. I
press 1 to continue, 2 to quit, 3
entered /usr/local/share,you can select a
to redisplay
suitable path as per your convenience.
1................................................
[ Starting to unpack ]
[ Processing package: Software
Package Installation (1/1) ]
[ Unpacking finished ]
[ Console installation done ]

Finally, open a new command prompt and type Scala -version and press Enter. You should see
the following −

Platform Command Output

Windows Scala code runner version 2.11.5 -- Copyright 2002-2013,

\>scala -version
LAMP/EPFL

Linux Scala code runner version 2.9.0.1 – Copyright 2002-2013,

$scala -version
LAMP/EPFL

Department of AI & DSPage 6

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Basic Syntax:

In a Scala program, it can be defined as a collection of objects that communicate via invoking
each other’s methods. Let us now briefly look into what do class, object, methods and instance
variables mean.
 Object − Objects have states and behaviors. An object is an instance of a class. Example
− A dog has states - color, name, breed as well as behaviors - wagging, barking, and
eating.
 Class − A class can be defined as a template/blueprint that describes the behaviors/states
that are related to the class.
 Methods − A method is basically a behavior. A class can contain many methods. It is in
methods where the logics are written, data is manipulated and all the actions are
executed.
 Fields − Each object has its unique set of instance variables, which are called fields. An
object's state is created by the values assigned to these fields.
 Closure − A closure is a function, whose return value depends on the value of one or
more variables declared outside this function.
 Traits − A trait encapsulates method and field definitions, which can then be reused by
mixing them into classes. Traits are used to define object types by specifying the
signature of the supported methods.
First Scala Program
We can execute a Scala program in two modes: one is interactive mode and another isscript
mode.

Interactive Mode

Open the command prompt and use the following command to open Scala.
\>scala
If Scala is installed in your system, the following output will be displayed −
Welcome to Scala version 2.9.0.1
Type in expressions to have them evaluated.
Type :help for more information.
Type the following text to the right of the Scala prompt and press the Enter key −

Department of AI & DSPage 7

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

scala> println("Hello, Scala!");

It will produce the following result −
Hello, Scala!
Script Mode
Use the following instructions to write a Scala program in script mode. Open notepad and add
the following code into it.

Example

object HelloWorld {
/* This is my first java program.
* This will print 'Hello World' as the output
*/
def main(args: Array[String]) {
println("Hello, world!") // prints Hello World
}
}
Save the file as − HelloWorld.scala.
Open the command prompt window and go to the directory where the program file is saved.
The ‘scalac’ command is used to compile the Scala program and it will generate a few class
files in the current directory. One of them will be called HelloWorld.class. This is a bytecode
which will run on Java Virtual Machine (JVM) using ‘scala’ command.
Use the following command to compile and execute your Scala program.
\> scalac HelloWorld.scala
\> scala HelloWorld

Output

Hello, World!
Basic Syntax
The following are the basic syntaxes and coding conventions in Scala programming.
 Case Sensitivity − Scala is case-sensitive, which means identifier Hello and hellowould
have different meaning in Scala.
 Class Names − For all class names, the first letter should be in Upper Case. If several
words are used to form a name of the class, each inner word's first letter should be in
Upper Case.

Department of AI & DSPage 8

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Example − class MyFirstScalaClass.

 Method Names − All method names should start with a Lower Case letter. If multiple
words are used to form the name of the method, then each inner word's first letter should
be in Upper Case.
Example − def myMethodName()
 Program File Name − Name of the program file should exactly match the object name.
When saving the file you should save it using the object name (Remember Scala is case-
sensitive) and append ‘.scala’ to the end of the name. (If the file name and the object
name do not match your program will not compile).
Example − Assume 'HelloWorld' is the object name. Then the file should be saved as
'HelloWorld.scala'.
 def main(args: Array[String]) − Scala program processing starts from the main()
method which is a mandatory part of every Scala Program.
Scala Identifiers
All Scala components require names. Names used for objects, classes, variables and methods
are called identifiers. A keyword cannot be used as an identifier and identifiers are case-
sensitive. Scala supports four types of identifiers.

Alphanumeric Identifiers

An alphanumeric identifier starts with a letter or an underscore, which can be followed by

further letters, digits, or underscores. The '$' character is a reserved keyword in Scala and
should not be used in identifiers.
Following are legal alphanumeric identifiers −
age, salary, _value, __1_value
Following are illegal identifiers −
$salary, 123abc, -salary

Operator Identifiers

An operator identifier consists of one or more operator characters. Operator characters are
printable ASCII characters such as +, :, ?, ~ or #.
Following are legal operator identifiers −
+ ++ ::: <?> :>

Department of AI & DSPage 9

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

The Scala compiler will internally "mangle" operator identifiers to turn them into legal Java
identifiers with embedded $ characters. For instance, the identifier :-> would be represented
internally as $colon$minus$greater.

Mixed Identifiers

A mixed identifier consists of an alphanumeric identifier, which is followed by an underscore

and an operator identifier.
Following are legal mixed identifiers −
unary_+, myvar_=
Here, unary_+ used as a method name defines a unary + operator and myvar_= used as method
name defines an assignment operator (operator overloading).

Literal Identifiers

A literal identifier is an arbitrary string enclosed in back ticks (` . . . `).

Following are legal literal identifiers −
`x` `<clinit>` `yield`
Scala Keywords
The following list shows the reserved words in Scala. These reserved words may not be used as
constant or variable or any other identifier names.

abstract case catch class

def do else extends

false final finally for

forSome if implicit import

lazy match new Null

object override package private

protected return sealed super

this throw trait Try

true type val Var

while with yield

Department of AI & DSPage 10

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

- : = =>

<- <: <% >:

# @

Comments in Scala
Scala supports single-line and multi-line comments very similar to Java. Multi-line comments
may be nested, but are required to be properly nested. All characters available inside any
comment are ignored by Scala compiler.
object HelloWorld {
/* This is my first java program.
* This will print 'Hello World' as the output
* This is an example of multi-line comments.
*/
def main(args: Array[String]) {
// Prints Hello World
// This is also an example of single line comment.
println("Hello, world!")
}
}

Blank Lines and Whitespace

A line containing only whitespace, possibly with a comment, is known as a blank line, and
Scala totally ignores it. Tokens may be separated by whitespace characters and/or comments.
Newline Characters
Scala is a line-oriented language where statements may be terminated by semicolons (;) or
newlines. A semicolon at the end of a statement is usually optional. You can type one if you
want but you don't have to if the statement appears by itself on a single line. On the other hand,
a semicolon is required if you write multiple statements on a single line. Below syntax is the
usage of multiple statements.
val s = "hello"; println(s)

1.2 Variables and Data Types

Variables are nothing but reserved memory locations to store values. This means that when you
create a variable, you reserve some space in memory.

Department of AI & DSPage 11

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Based on the data type of a variable, the compiler allocates memory and decides what can be
stored in the reserved memory. Therefore, by assigning different data types to variables, you
can store integers, decimals, or characters in these variables.
Variable Declaration
Scala has a different syntax for declaring variables. They can be defined as value, i.e., constant
or a variable. Here, myVar is declared using the keyword var. It is a variable that can change
value and this is called mutable variable. Following is the syntax to define a variable
using var keyword −

Syntax

var myVar : String = "Foo"

Here, myVal is declared using the keyword val. This means that it is a variable that cannot be
changed and this is called immutable variable. Following is the syntax to define a variable
using val keyword −

Syntax

val myVal : String = "Foo"

Variable Data Types
The type of a variable is specified after the variable name and before equals sign. You can
define any type of Scala variable by mentioning its data type as follows −

Syntax

val or val VariableName : DataType = [Initial Value]

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

Syntax

var myVar :Int;

val myVal :String;
Variable Type Inference
When you assign an initial value to a variable, the Scala compiler can figure out the type of the
variable based on the value assigned to it. This is called variable type inference. Therefore, you
could write these variable declarations like this −

Syntax

Department of AI & DSPage 12

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

var myVar = 10;

val myVal = "Hello, Scala!";
Here, by default, myVar will be Int type and myVal will become String type variable.
Multiple assignments
Scala supports multiple assignments. If a code block or method returns a Tuple (Tuple − Holds
collection of Objects of different types), the Tuple can be assigned to a val variable. [Note − We
will study Tuples in subsequent chapters.]

Syntax

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

And the type inference gets it right −

Syntax

val (myVar1, myVar2) = Pair(40, "Foo")

Example Program
The following is an example program that explains the process of variable declaration in Scala.
This program declares four variables — two variables are defined with type declaration and
remaining two are without type declaration.

Example

object Demo {
def main(args: Array[String]) {
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);
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.

Command

Department of AI & DSPage 13

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

\>scalac Demo.scala
\>scala Demo

Output

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

Variable Scope
Variables in Scala can have three different scopes depending on the place where they are being
used. They can exist as fields, as method parameters and as local variables. Below are the
details about each type of scope.

Fields

Fields are variables that belong to an object. The fields are accessible from inside every method
in the object. Fields can also be accessible outside the object depending on what access
modifiers the field is declared with. Object fields can be both mutable and immutable types and
can be defined using either var or val.

Method Parameters

Method parameters are variables, which are used to pass the value inside a method, when the
method is called. Method parameters are only accessible from inside the method but the objects
passed in may be accessible from the outside, if you have a reference to the object from outside
the method. Method parameters are always immutable which are defined byval keyword.

Local Variables

Local variables are variables declared inside a method. Local variables are only accessible from
inside the method, but the objects you create may escape the method if you return them from the
method. Local variables can be both mutable and immutable types and can be defined using
either var or val.
Data types:

Scala has all the same data types as Java, with the same memory footprint and precision.
Following is the table giving details about all the data types available in Scala −

Sr.No Data Type & Description

Department of AI & DSPage 14

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

1 Byte
8 bit signed value. Range from -128 to 127

2 Short
16 bit signed value. Range -32768 to 32767

3 Int
32 bit signed value. Range -2147483648 to 2147483647

4 Long
64 bit signed value. -9223372036854775808 to 9223372036854775807

5 Float
32 bit IEEE 754 single-precision float

6 Double
64 bit IEEE 754 double-precision float

7 Char
16 bit unsigned Unicode character. Range from U+0000 to U+FFFF

8 String
A sequence of Chars

9 Boolean
Either the literal true or the literal false

10 Unit
Corresponds to no value

11 Null

Department of AI & DSPage 15

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

null or empty reference

12 Nothing
The subtype of every other type; includes no values

13 Any
The supertype of any type; any object is of type Any

14 AnyRef
The supertype of any reference type

All the data types listed above are objects. There are no primitive types like in Java. This means
that you can call methods on an Int, Long, etc.
Scala Basic Literals
The rules Scala uses for literals are simple and intuitive. This section explains all basic Scala
Literals.

Integral Literals

Integer literals are usually of type Int, or of type Long when followed by a L or l suffix. Here
are some integer literals −
0
035
21
0xFFFFFFFF
0777L

Floating Point Literal

Floating point literals are of type Float when followed by a floating point type suffix F or f, and
are of type Double otherwise. Here are some floating point literals −
0.0
1e30f
3.14159f
1.0e100
.1

Department of AI & DSPage 16

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Boolean Literals

The Boolean literals true and false are members of type Boolean.

Symbol Literals

A symbol literal 'x is a shorthand for the expression scala.Symbol("x"). Symbol is a case class,
which is defined as follows.
package scala
final case class Symbol private (name: String) {
override def toString: String = "'" + name
}

Character Literals

A character literal is a single character enclosed in quotes. The character is either a printable
Unicode character or is described by an escape sequence. Here are some character literals −
'a'
'\u0041'
'\n'
'\t'

String Literals

A string literal is a sequence of characters in double quotes. The characters are either printable
Unicode character or are described by escape sequences. Here are some string literals −
"Hello,\nWorld!"
"This string contains a \" character."

Multi-Line Strings

A multi-line string literal is a sequence of characters enclosed in triple quotes """ ... """. The
sequence of characters is arbitrary, except that it may contain three or more consecutive quote
characters only at the very end.
Characters must not necessarily be printable; newlines or other control characters are also
permitted. Here is a multi-line string literal −
"""the present string
spans three
lines."""

Null Values
Department of AI & DSPage 17
 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

The null value is of type scala.Null and is thus compatible with every reference type. It denotes
a reference value which refers to a special "null" object.
Escape Sequences
The following escape sequences are recognized in character and string literals.

Escape Sequences Unicode Description

\b \u0008 backspace BS

\t \u0009 horizontal tab HT

\n \u000c formfeed FF

\f \u000c formfeed FF

\r \u000d carriage return CR

\" \u0022 double quote "

\' \u0027 single quote .

\\ \u005c backslash \

A character with Unicode between 0 and 255 may also be represented by an octal escape, i.e., a
backslash '\' followed by a sequence of up to three octal characters. Following is the example to
show few escape sequence characters −

Example

object Test {
def main(args: Array[String]) {
println("Hello\tWorld\n\n" );
}
}

Department of AI & DSPage 18

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

When the above code is compiled and executed, it produces the following result −

Output

Hello World

1.4 Operators :

An operator is a symbol that tells the compiler to perform specific mathematical or logical
manipulations. Scala is rich in built-in operators and provides the following types of operators −

 Arithmetic Operators
 Relational Operators
 Logical Operators
 Bitwise Operators
 Assignment Operators
This chapter will examine the arithmetic, relational, logical, bitwise, assignment and other
operators one by one.
Arithmetic Operators
The following arithmetic operators are supported by Scala language. For example, let us assume
variable A holds 10 and variable B holds 20, then –

Operator Description Example

+ Adds two operands A + B will give 30

- Subtracts second operand from the first A - B will give -10

* Multiplies both operands A * B will give 200

/ Divides numerator by de-numerator B / A will give 2

% Modulus operator finds the remainder after B % A will give 0

Department of AI & DSPage 19

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

division of one number by another

Relational Operators
The following relational operators are supported by Scala language. For example let us assume
variable A holds 10 and variable B holds 20, then −

Operator Description Example

== Checks if the values of two operands are equal or (A == B) is not true.

not, if yes then condition becomes true.

!= Checks if the values of two operands are equal or (A != B) is true.

not, if values are not equal then condition becomes
true.

> Checks if the value of left operand is greater than (A > B) is not true.
the value of right operand, if yes then condition
becomes true.

< Checks if the value of left operand is less than the (A < B) is true.
value of right operand, if yes then condition
becomes true.

>= Checks if the value of left operand is greater than (A >= B) is not true.
or equal to the value of right operand, if yes then
condition becomes true.

<= Checks if the value of left operand is less than or (A <= B) is true.
equal to the value of right operand, if yes then
condition becomes true.

Logical Operators

Department of AI & DSPage 20

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

The following logical operators are supported by Scala language. For example, assume variable
A holds 1 and variable B holds 0, then −
Show Examples

Operator Description Example

&& It is called Logical AND operator. If both the (A && B) is false.

operands are non zero then condition becomes
true.

|| It is called Logical OR Operator. If any of the two (A || B) is true.

operands is non zero then condition becomes true.

! It is called Logical NOT Operator. Use to !(A && B) is true.

reverses the logical state of its operand. If a
condition is true then Logical NOT operator will
make false.

Bitwise Operators
Bitwise operator works on bits and perform bit by bit operation. The truth tables for &, |, and ^
are as follows −

p q p&q p|q p^q

0 0 0 0 0

0 1 0 1 1

1 1 1 1 0

1 0 0 1 1

Assume if A = 60; and B = 13; now in binary format they will be as follows −

Department of AI & DSPage 21

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

A = 0011 1100
B = 0000 1101
-----------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
The Bitwise operators supported by Scala language is listed in the following table. Assume
variable A holds 60 and variable B holds 13, then −

Operato Description Example

r

& Binary AND Operator copies a bit to the result if (A & B) will give 12, which is 0000 1100
it exists in both operands.

| Binary OR Operator copies a bit if it exists in (A | B) will give 61, which is 0011 1101
either operand.

^ Binary XOR Operator copies the bit if it is set in (A ^ B) will give 49, which is 0011 0001
one operand but not both.

~ Binary Ones Complement Operator is unary and (~A ) will give -61, which is 1100 0011 in
has the effect of 'flipping' bits. 2's complement form due to a signed
binary number.

<< Binary Left Shift Operator. The bit positions of A << 2 will give 240, which is 1111 0000
the left operands value is moved left by the
number of bits specified by the right operand.

>> Binary Right Shift Operator. The Bit positions of A >> 2 will give 15, which is 1111
the left operand value is moved right by the
number of bits specified by the right operand.

>>> Shift right zero fill operator. The left operands A >>>2 will give 15 which is 0000 1111
value is moved right by the number of bits

Department of AI & DSPage 22

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

specified by the right operand and shifted values

are filled up with zeros.

Assignment Operators
There are following assignment operators supported by Scala language −
Show Examples

Operator Description Example

= Simple assignment operator, Assigns values from right C = A + B will assign value of A
side operands to left side operand + B into C

+= Add AND assignment operator, It adds right operand to C += A is equivalent to C = C + A

the left operand and assign the result to left operand

-= Subtract AND assignment operator, It subtracts right C -= A is equivalent to C = C - A

operand from the left operand and assign the result to
left operand

*= Multiply AND assignment operator, It multiplies right C *= A is equivalent to C = C * A

operand with the left operand and assign the result to
left operand

/= Divide AND assignment operator, It divides left C /= A is equivalent to C = C / A

operand with the right operand and assign the result to
left operand

%= Modulus AND assignment operator, It takes modulus C %= A is equivalent to C = C %

using two operands and assign the result to left operand A

<<= Left shift AND assignment operator C <<= 2 is same as C = C << 2

>>= Right shift AND assignment operator C >>= 2 is same as C = C >> 2

Department of AI & DSPage 23

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

&= Bitwise AND assignment operator C &= 2 is same as C = C & 2

^= bitwise exclusive OR and assignment operator C ^= 2 is same as C = C ^ 2

|= bitwise inclusive OR and assignment operator C |= 2 is same as C = C | 2

Operators Precedence in Scala

Operator precedence determines the grouping of terms in an expression. This affects how an
expression is evaluated. Certain operators have higher precedence than others; for example, the
multiplication operator has higher precedence than the addition operator −
For example, x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher
precedence than +, so it first gets multiplied with 3*2 and then adds into 7.
Take a look at the following table. Operators with the highest precedence appear at the top of
the table and those with the lowest precedence appear at the bottom. Within an expression,
higher precedence operators will be evaluated first.

Category Operator Associativity

Postfix () [] Left to right

Unary !~ Right to left

Multiplicative */% Left to right

Additive +- Left to right

Shift >> >>> << Left to right

Relational > >= < <= Left to right

Equality == != Left to right

Department of AI & DSPage 24
 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Bitwise AND & Left to right

Bitwise XOR ^ Left to right

Bitwise OR | Left to right

Logical AND && Left to right

Logical OR || Left to right

Assignment = += -= *= /= %= >>= <<= &= Right to left

^= |=

Comma , Left to right

1.5: Expressions, Values, and Types

Basic Expressions

The code below shows a basic expression in Scala :

val x = 5 + 10 // EXPRESSION

Expressions are evaluated by the compiler to a value, in this case 15. They also have a type, in
this case Int. The type gets figured out by the compiler without us having to specify it. This is
called Type Inference in Scala.

The above expression is mathematical. We could also write another expression that tests for
equality like so:

println(x == 3)

This expression evaluates to a boolean, checking whether or not the value of x is 3, which in this
case is false.

Department of AI & DSPage 25

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Instructions vs Expressions

 Instructions tell the computer to go and do something, for example print to the console or
change the value of a variable. These are used in imperative languages such as Java or
Python
 Expressions something that has a value and/or a type. In Scala (and in functional
programming in general) we will start to think in terms of Expressions.
 Everything in Scala is an Expression. Only definitions such as val or class or package are
not expressions, everything else is.

We can look at an if expression in Scala to see an example of this.

val someCondition = true

val conditionedValue = if(someCondition) 10 else 5

What this code is saying for the conditionedValue is “if someCondition is true then the value is
10, otherwise 5”. This is an expression, because it gives back a value.

You could also just write this straight to the console (i.e. without storing it in a val or var) as
below. Both of these lines are expressions in the parentheses that return a value:

println(if(someCondition) 10 else 5)

println(2 + 3)

Values and types

Create an object called Values and extend it from App, so that we can run it. Type in the
following code:

object Values extends App {

val x: Int = 99

println(x)

Here we are declaring a VALUE called x, and we are telling the compiler it is of type Int. We
then assign it the value 99. On the next line, we simply print out the value

A key thing to note here, is that once a VAL has been declared, it can’t be reassigned.

Department of AI & DSPage 26

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

For example, the following code would produce an error :

object Values extends App {

val x: Int = 42

println(x)

x = 66

So remember that Vals are immutable. The functional programming style of Scala encourages
the use of these immutable vals.

Type Inference

It isn’t always necessary to include the type when declaring a val. You could instead type:

object Values extends App {

val x = 42

println(x)

And this would run fine. The type is detected by the compiler by looking at the value assigned to
the variable. This is known as Type Inference.

The Basic Types

These are some of the really basic types in Scala, which you should be familiar with from other
programming languages:

val myString: String = "James"

val myBoolean: Boolean = true

val myChar: Char = 'd'

val myInt: Int = 33

val myShort: Short = 326

Department of AI & DSPage 27

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

val myLong: Long = 35263256234L // notice the L on the end - this tells the compiler its a Long

val myFloat: Float = 3.0f // again notice the f on the end

val myDouble: Double = 4.27

1.6 Classes and objects

A class is a blueprint for objects. Once you define a class, you can create objects from the class
blueprint with the keyword new. Through the object you can use all functionalities of the
defined class.
In scala, a class can contain:

 Data member
 Member method
 Constructor
 Block
 Nested class
 Super class information etc.

You must initialize all instance variables in the class. There is no default scope. If you don't
specify access scope, it is public. There must be an object in which main method is defined. It
provides starting point for your program. Here, we have created an example of class.

The following diagram demonstrates the class and object by taking an example of class student,
which contains the member variables (name and roll no) and member methods (setName() and
setRollNo()). Finally all are members of the class. Class is a blue print and objects are real here.
In the following diagram, Student is a class and Harini, John, and Maria are the objects of
Student class, those are having name and roll-number.

Department of AI & DSPage 28

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Basic Class
class Student{
var id:Int = 0; // All fields must be initialized
var name:String = null;
}
object MainObject{
def main(args:Array[String]){
var s = new Student() // Creating an object
println(s.id+" "+s.name);
}
}
Output:
0 null

Scala Sample Example2 of Class

In scala, you can create class like this also. Here, constructor is created in class definition. This is
called primary constructor.

class Student(id:Int, name:String){ // Primary constructor

def show(){
println(id+" "+name)
}
}
object MainObject{
def main(args:Array[String]){
var s = new Student(100,"Martin") // Passing values to constructor
s.show() // Calling a function by using an object
}
}
Output:
100 Martin

Scala Example of class that maintains the records of students

class Student(id:Int, name:String){

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

Department of AI & DSPage 29

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

student2.getRecord();
}
}
Output:
101 Raju
102 Martin
Scala Anonymous object

In scala, you can create anonymous object. An object which has no reference name is called
anonymous object. It is good to create anonymous object when you don't want to reuse it further.

Scala Anonymous object Example

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

Object

Object is a real world entity. It contains state and behavior. Laptop, car, cell phone are the real
world objects. Object typically has two characteristics:

1) State: data values of an object are known as its state.

2) Behavior: functionality that an object performs is known as its behavior.

Object in scala is an instance of class. It is also known as runtime entity.

1.7 Control statements and Looping Statements

Scala provides if statement to test the conditional expressions. It tests boolean conditional
expression which can be either true or false. Scala use various types of if else statements.

 If statement
 If-else statement

Department of AI & DSPage 30

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

 Nested if-else statement

 If-else-if ladder statement

if Statement
‘if’ statement consists of a Boolean expression followed by one or more statements.

Syntax

The syntax of an ‘if’ statement is as follows.

if(Boolean_expression) {
// Statements will execute if the Boolean expression is true
}
If the Boolean expression evaluates to true then the block of code inside the ‘if’ expression will
be executed. If not, the first set of code after the end of the ‘if’ expression (after the closing
curly brace) will be executed.
Try the following example program to understand conditional expressions (if expression) in
Scala Programming Language.

Example

object Demo {
def main(args: Array[String]) {
var x = 10;

if( x < 20 ){
println("This is if statement");
}
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

This is if statement

Department of AI & DSPage 31

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

If-else Statement
An ‘if’ statement can be followed by an optional else statement, which executes when the
Boolean expression is false.

Syntax

The syntax of a if...else is −

if(Boolean_expression){
//Executes when the Boolean expression is true
} else{
//Executes when the Boolean expression is false
}
Try the following example program to understand conditional statements (if- else statement) in
Scala Programming Language.

Example

object Demo {
def main(args: Array[String]) {
var x = 30;

if( x < 20 ){
println("This is if statement");
} else {
println("This is else statement");
}
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

This is else statement

Nested if-else Statement

Department of AI & DSPage 32

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

It is always legal to nest if-else statements, which means you can use one if or else-ifstatement
inside another if or else-if statement.

Syntax

The syntax for a nested if-else is as follows −

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

if(Boolean_expression 2){
//Executes when the Boolean expression 2 is true
}
}
Try the following example program to understand conditional statements (nested- if statement)
in Scala Programming Language.

Example

object Demo {
def main(args: Array[String]) {
var x = 30;
var y = 10;

if( x == 30 ){
if( y == 10 ){
println("X = 30 and Y = 10");
}
}
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

X = 30 and Y = 10

Department of AI & DSPage 33

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Scala If-Else-If Ladder Statement

The scala if-else-if ladder executes one condition among the multiple conditional statements.

Syntax

if (condition1){
//Code to be executed if condition1 is true
} else if (condition2){
//Code to be executed if condition2 is true
} else if (condition3){
//Code to be executed if condition3 is true
}
...
else {
//Code to be executed if all the conditions are false
}

If-Else-If Ladder Example

var number:Int = 85
if(number>=0 && number<50){
println ("fail")
}
else if(number>=50 && number<60){
println("D Grade")
}
else if(number>=60 && number<70){
println("C Grade")
}
else if(number>=70 && number<80){
println("B Grade")
}
else if(number>=80 && number<90){
println("A Grade")
}
else if(number>=90 && number<=100){
println("A+ Grade")
}
else println ("Invalid")

Output:

A Grade

Department of AI & DSPage 34

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Looping Statements

 There may be a situation, when you need to execute a block of code several number of
times. In general, statements are executed sequentially: The first statement in a function
is executed first, followed by the second, and so on.
 Programming languages provide various control structures that allow for more
complicated execution paths.
 A loop statement allows us to execute a statement or group of statements multiple times
and following is the general form of a loop statement in most of the programming
languages

Scala programming language provides the following types of loops to handle looping
requirements. Click the following links in the table to check their detail.

Sr.No Loop Type & Description

1 while loop
Repeats a statement or group of statements while a given condition is true. It tests
the condition before executing the loop body.

2 do-while loop
Like a while statement, except that it tests the condition at the end of the loop
body.

3 for loop
Executes a sequence of statements multiple times and abbreviates the code that
manages the loop variable.

Loop Control Statements

Loop control statements change execution from its normal sequence. When execution leaves a
scope, all automatic objects that were created in that scope are destroyed. As such Scala does not
support break or continue statement like Java does but starting from Scala version 2.8, there is a
way to break the loops. Click the following links to check the detail.
Sr.No Control Statement & Description

1 break statement
Terminates the loop statement and transfers execution to the statement
Department of AI & DSPage 35
 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

immediately following the loop.

The infinite Loop

A loop becomes an infinite loop if a condition never becomes false. If you are using Scala, the
while loop is the best way to implement infinite loop.

Example
object Demo {
def main(args: Array[String]) {
var a = 10;

// An infinite loop.
while( true ){
println( "Value of a: " + a );
}
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

If you will execute above code, it will go in infinite loop which you can terminate by pressing
Ctrl + C keys.

Value of a: 10
Value of a: 10
Value of a: 10
Value of a: 10

while loop Example

object MainObject {
def main(args: Array[String]) {
var a = 10; // Initialization
while( a<=20 ){ // Condition
println(a);
a = a+2 // Incrementation
}

Department of AI & DSPage 36

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

}
}

do-while loop example

object MainObject {
def main(args: Array[String]) {
var a = 10; // Initialization
do {
println( a );
a = a + 2; // Increment
}
while( a <= 20 ) // Condition
}
}

for loop
In scala, for loop is known as for-comprehensions. It can be used to iterate, filter and return an
iterated collection. The for-comprehension looks a bit like a for-loop in imperative languages,
except that it constructs a list of the results of all iterations.
Syntax
for( i <- range){
// statements to be executed
}
In the above syntax, range is a value which has start and end point. You can pass range by using
to or until keyword.

Scala for-loop example by using to keyword

object MainObject {
def main(args: Array[String]) {
for( a <- 1 to 10 ){
println(a);
}
}
}

The major difference between until and to is, to includes start and end value given in the range,
while until excludes last value of the range. So, the below example will print only 1 to 9.

Scala for-loop Example by using until keyword

object MainObject {
def main(args: Array[String]) {
for( a <- 1 until 10 ){
println(a);
}

Department of AI & DSPage 37

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

}
}

for-loop filtering Example

You can use for to filter your data. In the below example, we are filtering our data by passing a
conditional expression. This program prints only even values in the given range.

object MainObject {
def main(args: Array[String]) {
for( a <- 1 to 10 if a%2==0 ){
println(a);
}
}
}

for-loop Example by using yield keyword

In the above example, we have used yield keyword which returns a result after completing of
loop iterations. The for use buffer internally to store iterated result and after finishing all
iterations it yields the final result from that buffer. It does not work like imperative loop.

object MainObject {
def main(args: Array[String]) {
var result = for( a <- 1 to 10) yield a
for(i<-result){
println(i)
}
}
}

for-loop Example using by keyword

In the above example, we have used by keyword. The by keyword is used to skip the iteration.
When you code like: by 2 it means, this loop will skip all even iterations of loop.
object MainObject {
def main(args: Array[String]) {
for(i<-1 to 10 by 2){
println(i)
}
}
}

1.8 Strings

Department of AI & DSPage 38

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

String is a combination of characters or we can say it is a sequence of characters. It is index

based data structure and use linear approach to store data into memory. String is immutable in
scala like java. You can manipulate string and can apply method to get desire result but you can't
change original string object.

Creating a String
The following code can be used to create a String −
var greeting = "Hello world!";

or

var greeting:String = "Hello world!";

Whenever compiler encounters a string literal in the code, it creates a String object with its
value, in this case, “Hello world!”. String keyword can also be given in alternate declaration as
shown above.
Try the following example program.

Example

object Demo {
val greeting: String = "Hello, world!"

def main(args: Array[String]) {

println( greeting )
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

Hello, world!
As mentioned earlier, String class is immutable. String object once created cannot be changed.
If there is a necessity to make a lot of modifications to Strings of characters then use String
Builder Class available in Scala!.

Department of AI & DSPage 39

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

String Length
Methods used to obtain information about an object are known as accessor methods. One
accessor method that can be used with strings is the length() method, which returns the number
of characters contained in the string object.
Use the following code segment to find the length of a string −

Example

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

println( "String Length is : " + len );

}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

String Length is : 17
Concatenating Strings
The String class includes a method for concatenating two strings −
string1.concat(string2);
This returns a new string that is string1 with string2 added to it at the end. You can also use the
concat() method with string literals, as in −
"My name is ".concat("Zara");
Strings are more commonly concatenated with the + operator, as in −
"Hello," + " world" + "!"
Which results in −
"Hello, world!"

Department of AI & DSPage 40

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

The following lines of code to find string length.

Example

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

println("Dot " + str1 + str2);

}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

Dot Dot saw I was Tod

Creating Format Strings
You have printf() and format() methods to print output with formatted numbers. The String
class has an equivalent class method, format(), that returns a String object rather than a
PrintStream object.
Try the following example program, which makes use of printf() method −

Example

object Demo {
def main(args: Array[String]) {
var floatVar = 12.456
var intVar = 2000
var stringVar = "Hello, Scala!"

var fs = printf("The value of the float variable is " + "%f, while the value of the integer " +
"variable is %d, and the string" + "is %s", floatVar, intVar, stringVar);

println(fs)

Department of AI & DSPage 41

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.

command

\>scalac Demo.scala
\>scala Demo

Output

The value of the float variable is 12.456000,

while the value of the integer variable is 2000,
and the string is Hello, Scala!()
String Interpolation
String Interpolation is the new way to create Strings in Scala programming language. This
feature supports the versions of Scala-2.10 and later. String Interpolation: The mechanism to
embed variable references directly in process string literal.
There are three types (interpolators) of implementations in String Interpolation.
The ‘s’ String Interpolator
The literal ‘s’ allows the usage of variable directly in processing a string, when you prepend ‘s’
to it. Any String variable with in a scope that can be used with in a String. The following are the
different usages of ‘s’ String interpolator.
The following example code snippet for the implementation of ‘s’ interpolator in appending
String variable ($name) to a normal String (Hello) in println statement.
val name = “James”
println(s “Hello, $name”) //output: Hello, James
String interpolater can also process arbitrary expressions. The following code snippet for
Processing a String (1 + 1) with arbitrary expression (${1 + 1}) using ‘s’ String interpolator.
Any arbitrary expression can be embedded in ‘${}’.
println(s “1 + 1 = ${1 + 1}”) //output: 1 + 1 = 2
Try the following example program of implementing ‘s’ interpolator.

Example

Department of AI & DSPage 42

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

object Demo {
def main(args: Array[String]) {
val name = "James"

println(s"Hello, $name")
println(s"1 + 1 = ${1 + 1}")
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

Hello, James
1+1=2
The ‘ f ’ Interpolator
The literal ‘f’ interpolator allows to create a formatted String, similar to printf in C language.
While using ‘f’ interpolator, all variable references should be followed by the printf style
format specifiers such as %d, %i, %f, etc.
Let us take an example of append floating point value (height = 1.9d) and String variable (name
= “James”) with normal string. The following code snippet of implementing ‘f’ Interpolator.
Here $name%s to print (String variable) James and $height%2.2f to print (floating point value)
1.90.
val height = 1.9d
val name = "James"
println(f"$name%s is $height%2.2f meters tall") //James is 1.90 meters tall
It is type safe (i.e.) the variable reference and following format specifier should match otherwise
it is showing error. The ‘ f ’ interpolator makes use of the String format utilities (format
specifiers) available in Java. By default means, there is no % character after variable reference.
It will assume as %s (String).
‘raw’ Interpolator
The ‘raw’ interpolator is similar to ‘s’ interpolator except that it performs no escaping of literals
within a string. The following code snippets in a table will differ the usage of ‘s’ and ‘raw’

Department of AI & DSPage 43

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

interpolators. In outputs of ‘s’ usage ‘\n’ effects as new line and in output of ‘raw’ usage the ‘\n’
will not effect. It will print the complete string with escape letters.

‘s’ interpolator usage ‘raw’ interpolator usage

Program − Program −
object Demo { object Demo {
def main(args: Array[String]) { def main(args: Array[String]) {
println(s"Result = \n a \n b") println(raw"Result = \n a \n b")
} }
} }

Output −
Result =
a
b
String Methods
S.No Methods with Description

1 char charAt(int index)

Returns the character at the specified index.

2 int compareTo(Object o)
Compares this String to another Object.

3 int compareTo(String anotherString)

Compares two strings lexicographically.

4 int compareToIgnoreCase(String str)

Compares two strings lexicographically, ignoring case differences.

5 String concat(String str)

Concatenates the specified string to the end of this string.

6 boolean contentEquals(StringBuffer sb)

Returns true if and only if this String represents the same sequence of characters as the
specified StringBuffer.

7 static String copyValueOf(char[] data)

Returns a String that represents the character sequence in the array specified.

8 static String copyValueOf(char[] data, int offset, int count)

Returns a String that represents the character sequence in the array specified.

Department of AI & DSPage 44

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

9 boolean endsWith(String suffix)

Tests if this string ends with the specified suffix.

10 boolean equals(Object anObject)

Compares this string to the specified object.

11 boolean equalsIgnoreCase(String anotherString)

Compares this String to another String, ignoring case considerations.

12 byte getBytes()
Encodes this String into a sequence of bytes using the platform's default charset, storing the
result into a new byte array.

13 byte[] getBytes(String charsetName)

Encodes this String into a sequence of bytes using the named charset, storing the result into a
new byte array.

14 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

Copies characters from this string into the destination character array.

15 int hashCode()
Returns a hash code for this string.

16 int indexOf(int ch)

Returns the index within this string of the first occurrence of the specified character.

17 int indexOf(int ch, int fromIndex)

Returns the index within this string of the first occurrence of the specified character, starting
the search at the specified index.

18 int indexOf(String str)

Returns the index within this string of the first occurrence of the specified substring.

19 int indexOf(String str, int fromIndex)

Returns the index within this string of the first occurrence of the specified substring, starting
at the specified index.

20 String intern()
Returns a canonical representation for the string object.

21 int lastIndexOf(int ch)

Returns the index within this string of the last occurrence of the specified character.

22 int lastIndexOf(int ch, int fromIndex)

Returns the index within this string of the last occurrence of the specified character,
searching backward starting at the specified index.

23 int lastIndexOf(String str)

Returns the index within this string of the rightmost occurrence of the specified substring.

Department of AI & DSPage 45

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

24 int lastIndexOf(String str, int fromIndex)

Returns the index within this string of the last occurrence of the specified substring,
searching backward starting at the specified index.

25 int length()
Returns the length of this string.

26 boolean matches(String regex)

Tells whether or not this string matches the given regular expression.

27 boolean regionMatches(boolean ignoreCase, int toffset, String other, int offset, int len)
Tests if two string regions are equal.

28 boolean regionMatches(int toffset, String other, int offset, int len)

Tests if two string regions are equal.

29 String replace(char oldChar, char newChar)

Returns a new string resulting from replacing all occurrences of oldChar in this string with
newChar.

30 String replaceAll(String regex, String replacement

Replaces each substring of this string that matches the given regular expression with the
given replacement.

31 String replaceFirst(String regex, String replacement)

Replaces the first substring of this string that matches the given regular expression with the
given replacement.

32 String[] split(String regex)

Splits this string around matches of the given regular expression.

33 String[] split(String regex, int limit)

Splits this string around matches of the given regular expression.

34 boolean startsWith(String prefix)

Tests if this string starts with the specified prefix.

35 boolean startsWith(String prefix, int toffset)

Tests if this string starts with the specified prefix beginning a specified index.

36 CharSequence subSequence(int beginIndex, int endIndex)

Returns a new character sequence that is a subsequence of this sequence.

37 String substring(int beginIndex)

Returns a new string that is a substring of this string.

38 String substring(int beginIndex, int endIndex)

Returns a new string that is a substring of this string.

39 char[] toCharArray()

Department of AI & DSPage 46

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Converts this string to a new character array.

40 String toLowerCase()
Converts all of the characters in this String to lower case using the rules of the default locale.

41 String toLowerCase(Locale locale)

Converts all of the characters in this String to lower case using the rules of the given Locale.

42 String toString()
This object (which is already a string!) is itself returned.

43 String toUpperCase()
Converts all of the characters in this String to upper case using the rules of the default locale.

44 String toUpperCase(Locale locale)

Converts all of the characters in this String to upper case using the rules of the given Locale.

45 String trim()
Returns a copy of the string, with leading and trailing whitespace omitted.

46 static String valueOf(primitive data type x)

Returns the string representation of the passed data type argument.

Example
class StringExample{
var s1 = "Scala string example"
var s2 = "Hello Scala"
var s3 = "Hello Scala"
def show(){
println(s1.equals(s2))
println(s2.equals(s3))
}
}

object MainObject{
def main(args:Array[String]){
var s = new StringExample()
s.show()
}
}

1.9 Arrays

 Array is a collection of mutable values. It is an index based data structure which starts
from 0 index to n-1 where n is length of array.

Department of AI & DSPage 47

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

 Scala arrays can be generic. It means, you can have an Array[T], where T is a type
parameter or abstract type. Scala arrays are compatible with Scala sequences - you can
pass an Array[T] where a Seq[T] is required. It also supports all the sequence operations.

Following image represents the structure of array where first index is 0, last index is 9 and array
length is 10.

Types of array

 Single dimensional array

 Multidimensional array
Single Dimensional Array

Single dimensional array is used to store elements in linear order. Array elements are stored in
contiguous memory space. So, if you have any index of an array, you can easily traverse all the
elements of the array.

Syntax for Single Dimensional Array

var arrayName : Array[arrayType] = new Array[arrayType](arraySize); or

var arrayName = new Array[arrayType](arraySize) or
var arrayName : Array[arrayType] = new Array(arraySize); or
var arrayName = Array(element1, element2 ... elementN)

Array Example: Single Dimensional

class ArrayExample{
var arr = Array(1,2,3,4,5) // Creating single dimensional array
def show(){
for(a<-arr) // Traversing array elements
println(a)
println("Third Element = "+ arr(2)) // Accessing elements by using index
}
}

Department of AI & DSPage 48

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

object MainObject{
def main(args:Array[String]){
var a = new ArrayExample()
a.show()
}
}
Output:

1
2
3
4
5
Third Element = 3

Example 2: Single Dimensional

In this example, we have created an array by using new keyword which is used to initialize
memory for array. The entire array elements are set to default value, you can assign that later in
your code.

class ArrayExample{
var arr = new Array[Int](5) // Creating single dimensional array
def show(){
for(a<-arr){ // Traversing array elements
println(a)
}
println("Third Element before assignment = "+ arr(2)) // Accessing elements by using
index
arr(2) = 10 // Assigning new element at 2 index
println("Third Element after assignment = "+ arr(2))
}
}

object MainObject{
def main(args:Array[String]){
var a = new ArrayExample()
a.show()
}
}
Output:

Department of AI & DSPage 49

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

0
0
0
0
Third Element before assignment = 0
Third Element after assignment = 10
Scala Passing Array into Function

You can pass array as an argument to function during function call. Following example illustrate
the process how we can pass an array to the function.

class ArrayExample{
def show(arr:Array[Int]){
for(a<-arr) // Traversing array elements
println(a)
println("Third Element = "+ arr(2)) // Accessing elements by using index
}
}

object MainObject{
def main(args:Array[String]){
var arr = Array(1,2,3,4,5,6) // creating single dimensional array
var a = new ArrayExample()
a.show(arr) // passing array as an argument in the function
}
}
Output:

1
2
3
4
5
6
Third Element = 3

Array Example: Iterating By using Foreach Loop

You can also iterate array elements by using foreach loop. Let's see an example.

class ArrayExample{
var arr = Array(1,2,3,4,5) // Creating single dimensional array
arr.foreach((element:Int)=>println(element)) // Iterating by using foreach loop
}

Department of AI & DSPage 50

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

object MainObject{
def main(args:Array[String]){
new ArrayExample()
}
}
Output:

1
2
3
4
5

Multidimensional Array

Multidimensional array is an array which store data in matrix form. You can create from two
dimensional to three, four and many more dimensional array according to your need. Below we
have mentioned array syntax. Scala provides an ofDim method to create multidimensional array.

Multidimensional Array Syntax

var arrayName = Array.ofDim[ArrayType](NoOfRows,NoOfColumns) or

var arrayName = Array(Array(element...), Array(element...), ...)
Scala Multidimensional Array Example by using ofDim

In This example, we have created array by using ofDim method.

class ArrayExample{
var arr = Array.ofDim[Int](2,2) // Creating multidimensional array
arr(1)(0) = 15 // Assigning value
def show(){
for(i<- 0 to 1){ // Traversing elements by using loop
for(j<- 0 to 1){
print(" "+arr(i)(j))
}
println()
}
println("Third Element = "+ arr(1)(1)) // Accessing elements by using index
}
}

object MainObject{
def main(args:Array[String]){
var a = new ArrayExample()
a.show()

Department of AI & DSPage 51

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

}
}
Output:

00
15 0
Third Element = 0

Scala Multidimensional Array by using Array of Array

Apart from ofDim you can also create multidimensional array by using array of array. In this
example, we have created multidimensional array by using array of array.

class ArrayExample{
var arr = Array(Array(1,2,3,4,5), Array(6,7,8,9,10)) // Creating multidimensional array
def show(){
for(i<- 0 to 1){ // Traversing elements using loop
for(j<- 0 to 4){
print(" "+arr(i)(j))
}
println()
}
}
}

object MainObject{
def main(args:Array[String]){
var a = new ArrayExample()
a.show()
}
}
Output:

12345
6 7 8 9 10

Scala Addition of Two Matrix Example

You can manipulate array elements in scala. Here, we are adding two array elements and storing
result into third array.

class ArrayExample{
var arr1 = Array(Array(1,2,3,4,5), Array(6,7,8,9,10)) // Creating multidimensional array
var arr2 = Array(Array(1,2,3,4,5), Array(6,7,8,9,10))
var arr3 = Array.ofDim[Int](2,5)

Department of AI & DSPage 52

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

def show(){
for(i<- 0 to 1){ // Traversing elements using loop
for(j<- 0 to 4){
arr3(i)(j) = arr1(i)(j)+arr2(i)(j)
print(" "+arr3(i)(j))
}
println()
}
}
}

object MainObject{
def main(args:Array[String]){
var a = new ArrayExample()
a.show()
}
}
Output:
2 4 6 8 10
12 14 16 18 20

1.10 Functions
 A function is a group of statements that perform a task. You can divide up your code
into separate functions. How you divide up your code among different functions is up to
you, but logically, the division usually is so that each function performs a specific task.
 Scala has both functions and methods and we use the terms method and function
interchangeably with a minor difference. A Scala method is a part of a class which has a
name, a signature, optionally some annotations, and some bytecode where as a function
in Scala is a complete object which can be assigned to a variable. In other words, a
function, which is defined as a member of some object, is called a method.
 A function definition can appear anywhere in a source file and Scala permits nested
function definitions, that is, function definitions inside other function definitions. Most
important point to note is that Scala function's name can have characters like +, ++, ~,
&,-, --, \, /, :, etc.
Function Declarations
A Scala function declaration has the following form −
def functionName ([list of parameters]) : [return type]
Methods are implicitly declared abstract if you don’t use the equals sign and the method body.

Department of AI & DSPage 53

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Function Definitions
A Scala function definition has the following form −

Syntax

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

function body
return [expr]
}
Here, return type could be any valid Scala data type and list of parameters will be a list of
variables separated by comma and list of parameters and return type are optional. Very similar
to Java, a return statement can be used along with an expression in case function returns a
value. Following is the function which will add two integers and return their sum −

Syntax

object add {
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
A function, that does not return anything can return a Unit that is equivalent to void in Java and
indicates that function does not return anything. The functions which do not return anything in
Scala, they are called procedures.

Syntax

Here is the syntax −

object Hello{
def printMe( ) : Unit = {
println("Hello, Scala!")
}
}
Calling Functions
Scala provides a number of syntactic variations for invoking methods. Following is the standard
way to call a method −
functionName( list of parameters )

Department of AI & DSPage 54

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Example

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

return sum
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

Returned Value : 12

1.10.1 Higher-Order Functions

Scala allows the definition of higher-order functions. These are functions that take other
functions as parameters, or whose result is a function.
Try the following example program, apply() function takes another function f and a value v and
applies function f to v.
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() + "]"

}

Department of AI & DSPage 55

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Save the above program in Demo.scala. The following commands are used to compile and
execute this program.
Command
\>scalac Demo.scala
\>scala Demo
Output
[10]

1.10.2 Function Composition

In scala, functions can be composed from other functions. It is a process of composing in which
a function represents the application of two composed functions.

Let's see an example.

object MainObject {
def main(args: Array[String]) = {
var result = multiplyBy2(add2(10)) // Function composition
println(result)
}
def add2(a:Int):Int = {
a+2
}

def multiplyBy2(a:Int):Int = {
a*2
}
}
Output:

24

1.10.3 Scala Anonymous (lambda) Function

Anonymous function is a function that has no name but works as a function. It is good to create
an anonymous function when you don't want to reuse it latter.

You can create anonymous function either by using => (rocket) or _ (underscore) wild card in
scala.

Let's see an example.

Scala Anonymous function Example

Department of AI & DSPage 56

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

object MainObject {
def main(args: Array[String]) = {
var result1 = (a:Int, b:Int) => a+b // Anonymous function by using => (rocket)
var result2 = (_:Int)+(_:Int) // Anonymous function by using _ (underscore) wild card
println(result1(10,10))
println(result2(10,10))
}
}
Output:

20
20

1.10.4 Scala Multiline Expression

Expressions those are written in multiple lines are called multiline expression. In scala, be
carefull while using multiline expressions.

The following program explains about if we break an expression into multiline, the scala
compiler throw a warning message.

Scala Multiline Expression Example

def add1(a:Int, b:Int) = {

a
+b
}
The above program does not evaluate complete expression and just return b here. So, be careful
while using multiline expressions.

Output:

MainObject.scala:3: warning: a pure expression does nothing in statement

position; you may be omitting necessary parentheses
a
^
one warning found

10
You can apply following ways to avoid above problem.

Scala Example Multiline Expression

Department of AI & DSPage 57

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

object MainObject {
def add2(a:Int, b:Int) = {
a+
b
}
def add3(a:Int, b:Int) = {
(a
+b)
}
def main(args: Array[String]) = {
var result2 = add2(10,10)
var result3 = add3(10,10)
println(result2+"\n"+result3)
}
}
Output:

20
20

1.10.5 Function Currying

 In scala, method may have multiple parameter lists. When a method is called with a
fewer number of parameter lists, then this will yield a function taking the missing
parameter lists as its arguments.
 In other words it is a technique of transforming a function that takes multiple arguments
into a function that takes a single argument.

Scala Function Currying Example

object MainObject {
def add(a:Int)(b:Int) = {
a+b
}
def main(args: Array[String]) = {
var result = add(10)(10)
println("10 + 10 = "+result)
var addIt = add(10)_
var result2 = addIt(3)
println("10 + 3 = "+result2)
}
}
Output:
20

Department of AI & DSPage 58

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

1.10.6 Higher-Order Functions on Lists

1.10.7 Closures

A closure is a function, whose return value depends on the value of one or more variables
declared outside this function.

The following piece of code with anonymous function.

val multiplier = (i:Int) => i * 10

Here the only variable used in the function body, i * 10 , is i, which is defined as a parameter to
the function. Try the following code −

val multiplier = (i:Int) => i * factor

There are two free variables in multiplier: i and factor. One of them, i, is a formal parameter to
the function. Hence, it is bound to a new value each time multiplier is called. However, factor is
not a formal parameter, then what is this? Let us add one more line of code.

var factor = 3
val multiplier = (i:Int) => i * factor

Department of AI & DSPage 59

 Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I

Now factor has a reference to a variable outside the function but in the enclosing scope. The
function references factor and reads its current value each time. If a function has no external
references, then it is trivially closed over itself. No external context is required.

Example
object Demo {
def main(args: Array[String]) {
println( "multiplier(1) value = " + multiplier(1) )
println( "multiplier(2) value = " + multiplier(2) )
}
var factor = 3
val multiplier = (i:Int) => i * factor
}

Department of AI & DSPage 60