Tutorial SCALA Programming
Tutorial SCALA Programming
SCALA TUTORIAL
tutorialspoint.com
i
Scala Tutorial
Scala is a modern multi-paradigm programming language designed to express common programming
patterns in a concise, elegant, and type-safe way. Scala has been created by Martin Odersky and he
released the first version in 2003.
Scala smoothly integrates features of object-oriented and functional languages. This tutorial gives a great
understanding on Scala.
Audience
This tutorial has been prepared for the beginners to help them understand programming Language Scala
in simple and easy steps. After completing this tutorial, you will find yourself at a moderate level of
expertise in using Scala from where you can take yourself to next levels.
Prerequisites
Scala Programming is based on Java, so if you are aware of Java syntax, then it's pretty easy to learn
Scala. Further if you do not have expertise in Java but you know any other programming language like C,
C++ or Python, then it will also help in grasping Scala concepts very quickly.
the content and graphics on this tutorial are the property of tutorialspoint.com. Any content from
tutorialspoint.com or this tutorial may not be redistributed or reproduced in any way, shape, or form
without the written permission of tutorialspoint.com. Failure to do so is a violation of copyright laws.
This tutorial may contain inaccuracies or errors and tutorialspoint provides no guarantee regarding the
accuracy of the site or its contents including this tutorial. If you discover that the tutorialspoint.com site
or this tutorial content contains some errors, please contact us at [email protected]
TUTORIALS POINT
Simply Easy Learning
Table of Content
Scala Tutorial ........................................................................... 2
Audience .................................................................................. 2
Prerequisites ............................................................................ 2
Copyright & Disclaimer Notice .................................................. 2
Scala Overview ........................................................................ 8
Scala is object-oriented: ............................................................................ 8
Scala is functional:..................................................................................... 8
Scala is statically typed: ............................................................................ 8
Scala runs on the JVM: ............................................................................. 8
Scala can Execute Java Code: .................................................................. 9
Scala vs Java: ........................................................................................... 9
Scala Web Frameworks: ........................................................................... 9
TUTORIALS POINT
Simply Easy Learning
SYNTAX: ................................................................................................. 34
EXAMPLE: .............................................................................................. 34
Scala Arrays........................................................................... 64
Declaring Array Variables: ....................................................................... 64
Processing Arrays: .................................................................................. 65
Multi-Dimensional Arrays: ........................................................................ 66
Concatenate Arrays: ................................................................................ 66
Create Array with Range: ........................................................................ 67
Scala Arrays Methods: ............................................................................ 68
Scala Collections.................................................................... 69
Basic Operations on List: ......................................................................... 70
Concatenating Lists: ................................................................................ 71
Creating Uniform Lists: ............................................................................ 72
Tabulating a Function: ............................................................................. 72
Reverse List Order: ................................................................................. 72
Scala List Methods: ................................................................................. 73
Basic Operations on Set: ......................................................................... 76
Concatenating Sets: ................................................................................ 76
Find max, min elements in Set: ............................................................... 77
Find common values in Sets:................................................................... 77
Scala Set Methods: ................................................................................. 78
Basic Operations on Map: ....................................................................... 81
Concatenating Maps................................................................................ 81
Print Keys and Values from a Map: ......................................................... 82
Check for a Key in Map: .......................................................................... 82
Scala Map Methods: ................................................................................ 83
Iterate over the Tuple: ............................................................................. 86
Convert to String:..................................................................................... 87
Swap the Elements:................................................................................. 87
Using getOrElse() Method: ...................................................................... 88
Using isEmpty() Method: ......................................................................... 89
Scala Option Methods: ............................................................................ 89
Find Min & Max valued Element: ............................................................. 91
Find the length of the Iterator:.................................................................. 91
Scala Iterator Methods: ........................................................................... 92
TUTORIALS POINT
Simply Easy Learning
Example: ................................................................................................. 94
TUTORIALS POINT
Simply Easy Learning
CHAPTER
Scala Overview
cala, short for Scalable Language, is a hybrid functional programming language. It was created by Martin
Scala is object-oriented:
Scala is a pure object-oriented language in the sense that every value is an object. Types and behavior of objects
are described by classes and traits which will be explained in subsequent chapters.
Classes are extended by subclassing and a flexible mixin-based composition mechanism as a clean
replacement for multiple inheritance.
Scala is functional:
Scala is also a functional language in the sense that every function is a value and because every value is an object
so ultimately every function is an object.
Scala provides a lightweight syntax for defining anonymous functions, it supports higher-order functions, it
allows functions to be nested, and supports currying. These concepts will be explained in subsequent chapters.
TUTORIALS POINT
Simply Easy Learning
The Scala compiler compiles your Scala code into Java Byte Code, which can then be executed by the
scala command. The scala command is similar to the java command, in that it executes your compiled Scala
code.
Scala vs Java:
Scala has a set of features, which differ from Java. Some of these are:
Type inference.
Nested Functions.
Traits.
Closures.
TUTORIALS POINT
Simply Easy Learning
CHAPTER
he Scala language can be installed on any UNIX-like or Windows system. Before you start installing Scala
on your machine, you must have Java 1.5 or greater installed on your computer.
TUTORIALS POINT
Simply Easy Learning
convenience. Finally, open a new command prompt and type scala -versionand press Enter. You should see the
following:
C:\>scala -version
Scala code runner version 2.9.0.1 -- Copyright 2002-2011, LAMP/EPFL
C:\>
Congratulations, you have installed Scala on your Windows machine. Next section will teach you how to install scala
on your Mac OS X and Unix/Linux machines.
TUTORIALS POINT
Simply Easy Learning
$scala -version
Scala code runner version 2.9.0.1 -- Copyright 2002-2011, LAMP/EPFL
$
Congratulations, you have installed Scala on your UNIX/Linux machine.
TUTORIALS POINT
Simply Easy Learning
CHAPTER
f you have good understanding on Java, then it will be very easy for you to learn Scala. The biggest syntactic
difference between Scala and Java is that the ; line end character is optional. When we consider a Scala program
it can be defined as a collection of objects that communicate via invoking each others methods. Let us now briefly
look into what do class, object, methods and instant variables mean.
Object - Objects have states and behaviors. Example: A dog has states - color, name, breed as well as
behaviors - wagging, barking, eating. An object is an instance of a class.
Class - A class can be defined as a template/blueprint that describes the behaviors/states that object of its
type support.
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 instant variables, which are called fields. An object's state is created
by the values assigned to these fields.
TUTORIALS POINT
Simply Easy Learning
2.
3.
Open a command prompt window and go to the directory where you saved the program file. Assume it is C:\>
4.
Type 'scalac HelloWorld.scala' and press enter to compile your code. If there are no errors in your code, the
command prompt will take you to the next line.
5.
Above command 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).
6.
7.
Basic Syntax:
About Scala programs, it is very important to keep in mind the following points.
Case Sensitivity - Scala is case-sensitive, which means identifier Hello and hello would 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.
names
should
start
with
Lower
Case
letter.
If several words are used to form the name of the method, then each inner word's first letter should be in
Upper
Case.
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.
TUTORIALS POINT
Simply Easy Learning
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. There are following four types of
identifiers supported by Scala:
ALPHANUMERIC IDENTIFIERS
An alphanumeric identifier starts with a letter or 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
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:
+ ++ ::: <?> :>
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.
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
TUTORIALS POINT
Simply Easy Learning
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
=>
<-
<:
<%
>:
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!")
}
}
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:
val s = "hello"; println(s)
Scala Packages:
A package is a named module of code. For example, the Lift utility package is net.liftweb.util. The package
declaration is the first non-comment line in the source file as follows:
package com.liftcode.stuff
TUTORIALS POINT
Simply Easy Learning
Scala packages can be imported so that they can be referenced in the current compilation scope. The following
statement imports the contents of the scala.xml package:
import scala.xml._
You can import a single class and object, for example, HashMap from the scala.collection.mutable package:
import scala.collection.mutable.HashMap
You can import more than one class or object from a single package, for example, TreeMap and TreeSet from the
scala.collection.immutable package:
import scala.collection.immutable.{TreeMap, TreeSet}
TUTORIALS POINT
Simply Easy Learning
CHAPTER
cala 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:
Data Type
Description
Byte
Short
Int
Long
Float
Double
Char
String
A sequence of Chars
Boolean
Unit
Corresponds to no value
Null
Nothing
Any
AnyRef
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.
TUTORIALS POINT
Simply Easy Learning
INTEGER 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
0.0
1e30f
3.14159f
1.0e100
.1
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 consuctive quote characters only at the very end.
TUTORIALS POINT
Simply Easy Learning
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."""
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
\'
\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:
object Test {
def main(args: Array[String]) {
println("Hello\tWorld\n\n" );
}
}
When the above code is compiled and executed, it produces the following result:
Hello
World
TUTORIALS POINT
Simply Easy Learning
CHAPTER
Scala Variables
ariables are nothing but reserved memory locations to store values. This means that when you create a
Variable Declaration
Scala has the different syntax for the declaration of variables and they can be defined as value, i.e., constant or a
variable. Following is the syntax to define a variable using var keyword:
var myVar : String = "Foo"
Here, myVar is declared using the keyword var. This means that it is a variable that can change value and this is
called mutable variable. Following is the syntax to define a variable using val keyword:
val myVal : String = "Foo"
Here, myVal is declared using the keyword val. This means that it is a variable that can not be changed and this is
called immutable variable.
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;
TUTORIALS POINT
Simply Easy Learning
Multiple assignments:
Scala supports multiple assignments. If a code block or method returns a Tuple, the Tuple can be assigned to a val
variable. [Note: We will study Tuple in subsequent chapters.]
val (myVar1: Int, myVar2: String) = Pair(40, "Foo")
And the type inference gets it right:
val (myVar1, myVar2) = Pair(40, "Foo")
Variable Types:
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 or 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 mutable
and defined by val 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 or immutable types and can be defined using either var or val.
TUTORIALS POINT
Simply Easy Learning
CHAPTER
embers of packages, classes or objects can be labeled with the access modifiers private and
protected, and if we are not using either of these two keywords, then access will be assumed as public. These
modifiers restrict accesses to the members to certain regions of code. To use an access modifier, you include its
keyword in the definition of members of package, class or object as we will see in the following section.
Private members:
A private member is visible only inside the class or object that contains the member definition. Following is the
example:
class Outer {
class Inner {
private def f() { println("f") }
class InnerMost {
f() // OK
}
}
(new Inner).f() // Error: f is not accessible
}
In Scala, the access (new Inner).f() is illegal because f is declared private in Inner and the access is not from within
class Inner. By contrast, the first access to f in class InnerMost is OK, because that access is contained in the body
of class Inner. Java would permit both accesses because it lets an outer class access private members of its inner
classes.
Protected members:
A protected member is only accessible from subclasses of the class in which the member is defined. Following is
the example:
package p {
class Super {
protected def f() { println("f") }
}
class Sub extends Super {
f()
}
class Other {
(new Super).f() // Error: f is not accessible
}
}
TUTORIALS POINT
Simply Easy Learning
The access to f in class Sub is OK because f is declared protected in Super and Sub is a subclass of Super. By
contrast the access to f in Other is not permitted, because Other does not inherit from Super. In Java, the latter
access would be still permitted because Other is in the same package as Sub.
Public members:
Every member not labeled private or protected is public. There is no explicit modifier for public members. Such
members can be accessed from anywhere. Following is the example:
class Outer {
class Inner {
def f() { println("f") }
class InnerMost {
f() // OK
}
}
(new Inner).f() // OK because now f() is public
}
Scope of protection:
Access modifiers in Scala can be augmented with qualifiers. A modifier of the form private[X] or protected[X] means
that access is private or protected "up to" X, where X designates some enclosing package, class or singleton object.
Consider the following example:
package society {
package professional {
class Executive {
private[professional] var workDetails = null
private[society] var friends = null
private[this] var secrets = null
def help(another : Executive) {
println(another.workDetails)
println(another.secrets) //ERROR
}
}
}
}
Note the following points from the above example:
Variable workDetails will be accessible to any class within the enclosing package professional.
Variable friends will be accessible to any class within the enclosing package society.
Variable secrets will be accessible only on the implicit object within instance methods (this).
TUTORIALS POINT
Simply Easy Learning
CHAPTER
Scala Operators
n 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:
There are the following arithmetic operators supported by Scala language:
Assume variable A holds 10 and variable B holds 20, then:
Operator
Description
Example
A + B will give 30
B / A will give 2
B % A will give 0
Example:
Try the following example to understand all the arithmetic operators available in Scala Programming Language.
Copy and paste the following Scala program in Test.scala file and compile and run this program.
object Test {
def main(args: Array[String]) {
TUTORIALS POINT
Simply Easy Learning
var a = 10;
var b = 20;
var c = 25;
var d = 25;
println("a +
println("a println("a *
println("b /
println("b %
println("c %
b
b
b
a
a
a
=
=
=
=
=
=
"
"
"
"
"
"
+
+
+
+
+
+
(a
(a
(a
(b
(b
(c
+
*
/
%
%
b)
b)
b)
a)
a)
a)
);
);
);
);
);
);
}
}
This would produce the following result:
C:/>scalac Test.scala
C:/>scala Test
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
C:/>
Relational Operators:
There are the following relational operators supported by Scala language
Assume variable A holds 10 and variable B holds 20, then:
Operator
Description
Example
==
Checks if the values of two operands are equal or not, if yes then
condition becomes true.
(A == B) is not true.
!=
Checks if the values of two operands are equal or not, if values are
not equal then condition becomes true.
(A != B) is true.
>
Checks if the value of left operand is greater than the value of right
operand, if yes then condition becomes true.
<
Checks if the value of left operand is less than the value of right
operand, if yes then condition becomes true.
(A < B) is true.
>=
<=
Checks if the value of left operand is less than or equal to the value
of right operand, if yes then condition becomes true.
(A <= B) is true.
TUTORIALS POINT
Simply Easy Learning
Example:
The following simple example program demonstrates the relational operators. Copy and paste the following Scala
program in Test.scala file and compile and run this program.
object Test {
def main(args: Array[String]) {
var a = 10;
var b = 20;
println("a == b = " + (a == b) );
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) );
}
}
This would produce the following result:
C:/>scalac Test.scala
C:/>scala Test
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false
C:/>
Logical Operators:
There are the following logical operators supported by Scala language
Assume variable A holds 1 and variable B holds 0, then:
Operator
Description
Example
&&
(A && B) is false.
||
(A || B) is true.
Called Logical NOT Operator. Use to reverses the logical state of its
operand. If a condition is true then Logical NOT operator will make
false.
Example:
The following simple example program demonstrates the logical operators. Copy and paste the following Java
program in Test.scala file and compile and run this program:
object Test {
def main(args: Array[String]) {
var a = true;
var b = false;
TUTORIALS POINT
Simply Easy Learning
Bitwise Operators:
Bitwise operator works on bits and performs bit-by-bit operation. The truth tables for &, |, and ^ are as follows:
P
p&q
p|q
p^q
Assume if A = 60; and B = 13; now in binary format they will be as follows:
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:
Operator
Description
Example
&
TUTORIALS POINT
Simply Easy Learning
<<
>>
>>>
Shift right zero fill operator. The left operands value is moved
right by the number of bits specified by the right operand and
shifted values are filled up with zeros.
Example
The following simple example program demonstrates the bitwise operators. Copy and paste the following Scala
program in Test.scala file and compile and run this program.
object Test {
def main(args: Array[String]) {
var a = 60;
/* 60 = 0011 1100 */
var b = 13;
/* 13 = 0000 1101 */
var c = 0;
c = a & b;
/* 12 = 0000 1100 */
println("a & b = " + c );
c = a | b;
/* 61 = 0011 1101 */
println("a | b = " + c );
c = a ^ b;
/* 49 = 0011 0001 */
println("a ^ b = " + c );
c = ~a;
/* -61 = 1100 0011 */
println("~a = " + c );
c = a << 2;
/* 240 = 1111 0000 */
println("a << 2 = " + c );
c = a >> 2;
println("a >> 2
/* 215 = 1111 */
= " + c );
c = a >>> 2;
/* 215 = 0000 1111 */
println("a >>> 2 = " + c );
}
}
This would produce the following result:
C:/>scalac Test.scala
C:/>scala Test
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 15
TUTORIALS POINT
Simply Easy Learning
a >>> 15
C:/>
Assignment Operators:
There are following assignment operators supported by Scala language:
Operator
Description
Example
+=
C += A is equivalent to C = C + A
-=
C -= A is equivalent to C = C - A
*=
C *= A is equivalent to C = C * A
/=
C /= A is equivalent to C = C / A
%=
C %= A is equivalent to C = C %
A
<<=
>>=
&=
^=
C ^= 2 is same as C = C ^ 2
|=
C |= 2 is same as C = C | 2
Example:
The following simple example program demonstrates the assignment operators. Copy and paste the following Scala
program in Test.scala file and compile and run this program.
object Test {
def main(args: Array[String]) {
var a = 10;
var b = 20;
var c = 0;
c = a + b;
println("c = a + b
c += a ;
println("c += a
= " + c );
= " + c );
c -= a ;
println("c -= a = " + c );
c *= a ;
println("c *= a = " + c );
TUTORIALS POINT
Simply Easy Learning
a = 10;
c = 15;
c /= a ;
println("c /= a
= " + c );
a = 10;
c = 15;
c %= a ;
println("c %= a
= " + c );
c <<= 2 ;
println("c <<= 2
= " + c );
c >>= 2 ;
println("c >>= 2
= " + c );
c >>= 2 ;
println("c >>= a
= " + c );
c &= a ;
println("c &= 2
= " + c );
c ^= a ;
println("c ^= a
= " + c );
c |= a ;
println("c |= a
= " + c );
}
}
This would produce the following result:
C:/>scalac Test.scala
C:/>scala Test
c = a + b = 30
c += a = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a = 0
c ^= a = 10
c |= a = 10
C:/>
TUTORIALS POINT
Simply Easy Learning
Here, operators with the highest precedence appear at the top of the table, those with the lowest appear at the
bottom. Within an expression, higher precedence operators will be evaluated first.
Category
Operator
Associativity
Postfix
() []
Left toright
Unary
!~
Right to left
Multiplicative
*/%
Left to right
Additive
+-
Left to right
Shift
Leftto right
Relational
Left to right
Equality
== !=
Left to right
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
TUTORIALS POINT
Simply Easy Learning
CHAPTER
ollowing is the general form of a typical decision making IF...ELSE structure found in most of the
programming languages:
The if Statement:
An if statement consists of a Boolean expression followed by one or more statements .
SYNTAX:
The syntax of an if statement is:
if(Boolean_expression)
{
// Statements will execute if the Boolean expression is true
TUTORIALS POINT
Simply Easy Learning
}
If the boolean expression evaluates to true, then the block of code inside the if statement will be executed. If not, the
first set of code after the end of the if statement (after the closing curly brace) will be executed.
EXAMPLE:
object Test {
def main(args: Array[String]) {
var x = 10;
if( x < 20 ){
println("This is if statement");
}
}
}
This would produce the following result:
C:/>scalac Test.scala
C:/>scala Test
This is if statement
C:/>
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
}
EXAMPLE:
object Test {
def main(args: Array[String]) {
var x = 30;
if( x < 20 ){
println("This is if statement");
}else{
println("This is else statement");
}
}
}
This would produce the following result:
C:/>scalac Test.scala
C:/>scala Test
TUTORIALS POINT
Simply Easy Learning
An if can have zero or one else's and it must come after any else if's.
An if can have zero to many else if's and they must come before the else.
Once an else if succeeds, none of he remaining else if's or else's will be tested.
SYNTAX:
The syntax of an if...else if...else is:
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.
}
EXAMPLE:
object Test {
def main(args: Array[String]) {
var x = 30;
if( x == 10 ){
println("Value of X is 10");
}else if( x == 20 ){
println("Value of X is 20");
}else if( x == 30 ){
println("Value of X is 30");
}else{
println("This is else statement");
}
}
}
This would produce the following result:
C:/>scalac Test.scala
C:/>scala Test
Value of X is 30
C:/>
TUTORIALS POINT
Simply Easy Learning
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
}
}
You can nest else if...else in the similar way as we have nested if statement.
EXAMPLE:
object Test {
def main(args: Array[String]) {
var x = 30;
var y = 10;
if( x == 30 ){
if( y == 10 ){
println("X = 30 and Y = 10");
}
}
}
}
This would produce the following result:
C:/>scalac Test.scala
C:/>scala Test
X = 30 and Y = 10
C:/>
TUTORIALS POINT
Simply Easy Learning
CHAPTER
here 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 from 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 to check their detail.
Loop Type
TUTORIALS POINT
Simply Easy Learning
Description
while loop
do...while loop
Like a while statement, except that it tests the condition at the end of the loop
body
for loop
Executes a sequence of statements multiple times and abbreviates the code that
manages the loop variable.
while loop
A while loop statement repeatedly executes a target statement as long as a given condition is true.
Syntax:
The syntax of a while loop in Scala is:
while(condition){
statement(s);
}
Here, statement(s) may be a single statement or a block of statements. The condition may be any expression,
and true is any nonzero value. The loop iterates while the condition is true. When the condition becomes false,
program control passes to the line immediately following the loop.
Flow Diagram:
Here. key point of the while loop is that the loop might not ever run. When the condition is tested and the result is
false, the loop body will be skipped and the first statement after the while loop will be executed.
TUTORIALS POINT
Simply Easy Learning
Example:
object Test {
def main(args: Array[String]) {
// Local variable declaration:
var a = 10;
// while loop execution
while( a < 20 ){
println( "Value of a: " + a );
a = a + 1;
}
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19
C:/>
dowhile loop
Unlike while loop, which tests the loop condition at the top of the loop, the do...while loop checks its condition at
the bottom of the loop. A do...while loop is similar to a while loop, except that a do...while loop is guaranteed to
execute at least one time.
Syntax:
The syntax of a do...while loop in Scala is:
do{
statement(s);
}while( condition );
Notice that the conditional expression appears at the end of the loop, so the statement(s) in the loop execute once
before the condition is tested. If the condition is true, the flow of control jumps back up to do, and the statement(s) in
the loop execute again. This process repeats until the given condition becomes false.
TUTORIALS POINT
Simply Easy Learning
Flow Diagram:
Example:
object Test {
def main(args: Array[String]) {
// Local variable declaration:
var a = 10;
// do loop execution
do{
println( "Value of a: " + a );
a = a + 1;
}while( a < 20 )
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19
C:/>
TUTORIALS POINT
Simply Easy Learning
for loop
A for loop is a repetition control structure that allows you to efficiently write a loop that needs to execute a specific
number of times. There are various forms of for loop in Scala which are described below:
Example:
Following is the example of for loop with range using i to j syntax:
object Test {
def main(args:
var a = 0;
// for loop
for( a <- 1
println(
}
}
}
Array[String]) {
execution with a range
to 10){
"Value of a: " + a );
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
value of a: 1
value of a: 2
value of a: 3
value of a: 4
value of a: 5
value of a: 6
value of a: 7
value of a: 8
value of a: 9
value of a: 10
C:/>
Following is the example of for loop with range using i until j syntax:
object Test {
def main(args:
var a = 0;
// for loop
for( a <- 1
println(
}
}
}
Array[String]) {
execution with a range
until 10){
"Value of a: " + a );
TUTORIALS POINT
Simply Easy Learning
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
value of a: 1
value of a: 2
value of a: 3
value of a: 4
value of a: 5
value of a: 6
value of a: 7
value of a: 8
value of a: 9
C:/>
You can use multiple ranges separated by semicolon (;) within a for loop and in that case loop will iterate through
all the possible computations of the given ranges. Following is an example of using just two ranges, you can use
more than two ranges as well.
object Test {
def main(args:
var a = 0;
var b = 0;
// for loop
for( a <- 1
println(
println(
}
}
}
Array[String]) {
execution with a range
to 3; b <- 1 to 3){
"Value of a: " + a );
"Value of b: " + b );
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Value of a: 1
Value of b: 1
Value of a: 1
Value of b: 2
Value of a: 1
Value of b: 3
Value of a: 2
Value of b: 1
Value of a: 2
Value of b: 2
Value of a: 2
Value of b: 3
Value of a: 3
Value of b: 1
Value of a: 3
Value of b: 2
Value of a: 3
Value of b: 3
C:/>
TUTORIALS POINT
Simply Easy Learning
Example:
Following is the example of for loop with a collection of numbers. Here we created this collection usingList(). We will
study collections in a separate chapter.
object Test {
def main(args: Array[String]) {
var a = 0;
val numList = List(1,2,3,4,5,6);
// for loop execution with a collection
for( a <- numList ){
println( "Value of a: " + a );
}
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
value of a: 1
value of a: 2
value of a: 3
value of a: 4
value of a: 5
value of a: 6
C:/>
Example:
Following is the example of for loop along with filters:
object Test {
def main(args: Array[String]) {
var a = 0;
val numList = List(1,2,3,4,5,6,7,8,9,10);
TUTORIALS POINT
Simply Easy Learning
Example:
Following is the example to show the usage of for loop along with yield:
object Test {
def main(args: Array[String]) {
var a = 0;
val numList = List(1,2,3,4,5,6,7,8,9,10);
// for loop execution with a yield
var retVal = for{ a <- numList
if a != 3; if a < 8
}yield a
// Now print returned values using another loop.
for( a <- retVal){
println( "Value of a: " + a );
}
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
value of a: 1
TUTORIALS POINT
Simply Easy Learning
value
value
value
value
value
of
of
of
of
of
a:
a:
a:
a:
a:
2
4
5
6
7
C:/>
Description
break statement
break statement
As such there is no built-in break statement available in Scala, but if you are running Scala version 2.8, then there is
a way to use break statement. When the break statement is encountered inside a loop, the loop is immediately
terminated and program control resumes at the next statement following the loop.
Syntax:
The syntax of a break statement is bit unusual but it works:
// 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;
}
}
TUTORIALS POINT
Simply Easy Learning
Flow Diagram:
Example:
import scala.util.control._
object Test {
def main(args: Array[String]) {
var a = 0;
val numList = List(1,2,3,4,5,6,7,8,9,10);
val loop = new Breaks;
loop.breakable {
for( a <- numList){
println( "Value of a: " + a );
if( a == 4 ){
loop.break;
}
}
}
println( "After the loop" );
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Value of a: 1
Value of a: 2
Value of a: 3
Value of a: 4
After the loop
C:/>
TUTORIALS POINT
Simply Easy Learning
Example:
import scala.util.control._
object Test {
def main(args: Array[String]) {
var a = 0;
var b = 0;
val numList1 = List(1,2,3,4,5);
val numList2 = List(11,12,13);
val outer = new Breaks;
val inner = new Breaks;
outer.breakable {
for( a <- numList1){
println( "Value of a: " + a );
inner.breakable {
for( b <- numList2){
println( "Value of b: " + b );
if( b == 12 ){
inner.break;
}
}
} // inner breakable
}
} // outer breakable.
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Value of a: 1
Value of b: 11
Value of b: 12
Value of a: 2
Value of b: 11
Value of b: 12
Value of a: 3
Value of b: 11
Value of b: 12
Value of a: 4
Value of b: 11
Value of b: 12
Value of a: 5
Value of b: 11
Value of b: 12
C:/>
TUTORIALS POINT
Simply Easy Learning
Infinite Loop:
A loop becomes infinite loop if a condition never becomes false. If you are using Scala, the while loop is the best
way to implement infinite loop as follows
object Test {
def main(args: Array[String]) {
var a = 10;
// An infinite loop.
while( true ){
println( "Value of a: " + a );
}
}
}
If you will execute above code, it will go in infinite loop, which you can terminate by pressing Ctrl + C keys.
TUTORIALS POINT
Simply Easy Learning
CHAPTER
10
Scala Functions
function is a group of statements that together 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 leave off the equals sign and method body. The enclosing type is
then itself abstract.
Function Definitions:
A scala function definition has the following form:
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:
object add{
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
TUTORIALS POINT
Simply Easy Learning
return sum
}
}
A function, which does not return anything, can return Unit which 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.
Following 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 )
If function is being called using an instance of the object then we would use dot notation similar to Java as follows:
[instance.]functionName( list of parameters )
Following is the final example to define and then call the same function:
object Test {
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
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Returned Value : 12
C:/>
Scala functions are the heart of Scala programming and that's why Scala is assumed as a functional programming
language. Following are few important concepts related to Scala functions which should be understood by a Scala
programmer.
Functions Call-by-Name
Recursion Functions
Higher-Order Functions
Nested Functions
Anonymous Functions
TUTORIALS POINT
Simply Easy Learning
Currying Functions
Functions Call-by-Name
Typically, parameters to functions are by-value parameters; that is, the value of the parameter is determined before
it is passed to the function. But what if we need to write a function that accepts as a parameter an expression that
we don't want evaluated until it's called within our function? For this circumstance, Scala offers call-byname parameters.
A call-by-name mechanism passes a code block to the callee and each time the callee accesses the parameter, the
code block is executed and the value is calculated.
object Test {
def main(args: Array[String]) {
delayed(time());
}
def time() = {
println("Getting time in nano seconds")
System.nanoTime
}
def delayed( t: => Long ) = {
println("In delayed method")
println("Param: " + t)
t
}
}
Here, we declared the delayed method, which takes a call-by-name parameter by putting the => symbol between
the variable name and the type. When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
In delayed method
Getting time in nano seconds
Param: 81303808765843
Getting time in nano seconds
C:/>
Here, delayed prints a message demonstrating that the method has been entered. Next, delayed prints a message
with its value. Finally, delayed returns t.
TUTORIALS POINT
Simply Easy Learning
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Value of a : 7
Value of b : 5
C:/>
Recursive Functions
Recursion plays a big role in pure functional programming and Scala supports recursion functions very well.
Recursion means a function can call itself repeatedly. Following is a good example of recursion where we calculate
factorials of the passed number:
object Test {
def main(args: Array[String]) {
for (i <- 1 to 10)
println( "Factorial of " + i + ": = " + factorial(i) )
}
def factorial(n: BigInt): BigInt = {
if (n <= 1)
1
else
n * factorial(n - 1)
}
}
When the above code is compiled and executed, it produces the following result:
TUTORIALS POINT
Simply Easy Learning
C:/>scalac Test.scala
C:/>scala Test
Factorial of 1: = 1
Factorial of 2: = 2
Factorial of 3: = 6
Factorial of 4: = 24
Factorial of 5: = 120
Factorial of 6: = 720
Factorial of 7: = 5040
Factorial of 8: = 40320
Factorial of 9: = 362880
Factorial of 10: = 3628800
C:/>
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. For example in the following code, apply() function takes another function f and a
value v and applies function f to v:
object Test {
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() + "]"
TUTORIALS POINT
Simply Easy Learning
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
[10]
C:/>
Nested Functions
Scala allows you to define functions inside a function and functions defined inside other functions are called local
functions. Here is an implementation of a factorial calculator, where we use a conventional technique of calling a
second, nested method to do the work:
object Test {
def main(args: Array[String]) {
println( factorial(0) )
println( factorial(1) )
println( factorial(2) )
println( factorial(3) )
}
def factorial(i: Int): Int = {
def fact(i: Int, accumulator: Int): Int = {
if (i <= 1)
accumulator
else
fact(i - 1, i * accumulator)
}
fact(i, 1)
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
1
1
2
6
C:/>
Like a local variable declaration in many languages, a nested method is only visible inside the enclosing method. If
you try to call fact() outside of factorial(), you will get a compiler error.
Anonymous Functions
Scala provides a relatively lightweight syntax for defining anonymous functions. Anonymous functions in source
code are called function literals and at run time, function literals are instantiated into objects called function
values.
TUTORIALS POINT
Simply Easy Learning
Scala supports first-class functions, which means you can express functions in function literal syntax, i.e., (x: Int)
=> x + 1, and that functions can be represented by objects, which are called function values. The following
expression creates a successor function for integers:
var inc = (x:Int) => x+1
Variable inc is now a function that can be used the usual way:
var x = inc(7)-1
It is also possible to define functions with multiple parameters as follows:
var mul = (x: Int, y: Int) => x*y
Variable mul is now a function that can be used the usual way:
println(mul(3, 4))
It is also possible to define functions with no parameter as follows:
var userDir = () => { System.getProperty("user.dir") }
Variable userDir is now a function that can be used the usual way:
println( userDir )
= {
}
Here, the log( ) method takes two parameters: date and message. We want to invoke the method multiple times,
with the same value for date but different values for message. We can eliminate the noise of passing the date to
each call by partially applying that argument to the log( ) method. To do so, we first bind a value to the date
parameter and leave the second parameter unbound by putting an underscore at its place. The result is a partially
applied function that we've stored in a variable. We can now invoke this new method with only the unbound
argument message as follows:
import java.util.Date
object Test {
def main(args: Array[String]) {
val logWithDateBound = log(new Date, _ : String)
TUTORIALS POINT
Simply Easy Learning
logWithDateBound("message1" )
logWithDateBound("message2" )
logWithDateBound("message3" )
}
def log(date: Date, message: String)
println(date + "----" + message)
}
= {
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Thu Aug 18 01:41:07 GST 2011----message1
Thu Aug 18 01:41:08 GST 2011----message2
Thu Aug 18 01:41:08 GST 2011----message3
C:/>
Currying Functions
Currying transforms a function that takes multiple parameters into a chain of functions, each taking a single
parameter. Curried functions are defined with multiple parameter lists, as follows:
def strcat(s1: String)(s2: String) = s1 + s2
Alternatively, you can also use the following syntax to define a curried function:
def strcat(s1: String) = (s2: String) => s1 + s2
Following is the syntax to call a curried function:
strcat("foo")("bar")
You can define more than two parameters on a curried function based on your requirement. Let us take a complete
example to show currying concept:
object Test {
def main(args: Array[String]) {
val str1:String = "Hello, "
val str2:String = "Scala!"
println( "str1 + str2 = " + strcat(str1)(str2) )
}
def strcat(s1: String)(s2: String) = {
s1 + s2
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
str1 + str2 = Hello, Scala!
C:/>
TUTORIALS POINT
Simply Easy Learning
CHAPTER
11
Scala Closures
closure is a function, whose return value depends on the value of one or more variables declared
outside this function. Consider the following piece of code with anonymous function:
val multiplier = (i:Int) => i * 10
Here, the only variable used in the function body, i * 0, is i, which is defined as a parameter to the function. Now, let
us take another piece of 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
Now, factor has a reference to a variable outside the function but in the enclosing scope. Let us try the following
example:
object Test {
def main(args: Array[String]) {
println( "muliplier(1) value = " + multiplier(1) )
println( "muliplier(2) value = " + multiplier(2) )
}
var factor = 3
val multiplier = (i:Int) => i * factor
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
muliplier(1) value = 3
muliplier(2) value = 6
C:/>
Above 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.
TUTORIALS POINT
Simply Easy Learning
CHAPTER
12
Scala Strings
onsider the following simple example where we assign a string in a variable of type val:
object Test {
val greeting: String = "Hello, world!"
def main(args: Array[String]) {
println( greeting )
}
}
Here, the type of the value above is java.lang.String borrowed from Java, because Scala strings are also Java
strings. It is very good point to note that every Java class is available in Scala. As such, Scala does not have a
String class and makes use of Java Strings. So this chapter has been written keeping Java String as a base.
In Scala, as in Java, a string is an immutable object, that is, an object that cannot be modified. On the other hand,
objects that can be modified, like arrays, are called mutable objects. Since strings are very useful objects, in the rest
of this section, we present the most important methods class java.lang.String defines.
Creating Strings:
The most direct way to create a string is to write:
var greeting = "Hello world!";
or
var greeting:String = "Hello world!";
Whenever it encounters a string literal in your code, the compiler creates a String object with its value, in this case,
"Hello world!', but if you like, you can give String keyword as I have shown you in alternate declaration.
object Test {
val greeting: String = "Hello, world!"
def main(args: Array[String]) {
println( greeting )
}
}
When the above code is compiled and executed, it produces the following result:
TUTORIALS POINT
Simply Easy Learning
C:/>scalac Test.scala
C:/>scala Test
Hello, world!
C:/>
As I mentioned earlier, String class is immutable, so that once it is created a String object cannot be changed. If
there is a necessity to make a lot of modifications to Strings of characters, then you should use String Builder Class
available in Scala itself.
String Length:
Methods used to obtain information about an object are known as accessor methods. One accessor method that
you can use with strings is the length() method, which returns the number of characters contained in the string
object.
After the following two lines of code have been executed, len equals 17:
object Test {
def main(args: Array[String]) {
var palindrome = "Dot saw I was Tod";
var len = palindrome.length();
println( "String Length is : " + len );
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
String Length is : 17
C:/>
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!"
Let us look at the following example:
object Test {
def main(args: Array[String]) {
var str1 = "Dot saw I was ";
TUTORIALS POINT
Simply Easy Learning
String Methods:
Following is the list of methods defined by java.lang.String class and can be used directly in your Scala programs:
SN Methods with Description
1
int compareTo(Object o)
Compares this String to another Object.
TUTORIALS POINT
Simply Easy Learning
10
11
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
14
15
int hashCode()
Returns a hash code for this string.
16
17
18
19
20
String intern()
Returns a canonical representation for the string object.
21
22
TUTORIALS POINT
Simply Easy Learning
23
24
25
int length()
Returns the length of this string.
26
27
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
Tests if two string regions are equal.
28
29
30
31
32
33
34
35
36
37
38
39
char[] toCharArray()
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
42
String toString()
This object (which is already a string!) is itself returned.
TUTORIALS POINT
Simply Easy Learning
43
String toUpperCase()
Converts all of the characters in this String to upper case using the rules of the default locale.
44
45
String trim()
Returns a copy of the string, with leading and trailing whitespace omitted.
46
TUTORIALS POINT
Simply Easy Learning
CHAPTER
13
Scala Arrays
cala provides a data structure, the array, which stores a fixed-size sequential collection of elements of the
same type. An array is used to store a collection of data, but it is often more useful to think of an array as a
collection of variables of the same type.
Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare one array
variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent individual variables.
This tutorial introduces how to declare array variables, create arrays, and process arrays using indexed variables.
The index of the first element of an array is the number zero and the index of the last element is the total number
of elements minus one.
TUTORIALS POINT
Simply Easy Learning
Processing Arrays:
When processing array elements, we often use either for loop because all of the elements in an array are of the
same type and the size of the array is known. Here is a complete example of showing how to create, initialize and
process arrays:
object Test {
def main(args: Array[String]) {
var myList = Array(1.9, 2.9, 3.4, 3.5)
// Print all the array elements
for ( x <- myList ) {
println( x )
}
// Summing all elements
var total = 0.0;
for ( i <- 0 to (myList.length - 1)) {
total += myList(i);
}
println("Total is " + total);
// Finding the largest element
var max = myList(0);
for ( i <- 1 to (myList.length - 1) ) {
if (myList(i) > max) max = myList(i);
}
println("Max is " + max);
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5
TUTORIALS POINT
Simply Easy Learning
C:/>
Multi-Dimensional Arrays:
There are many situations where you would need to define and use multi-dimensional arrays (i.e., arrays whose
elements are arrays). For example, matrices and tables are examples of structures that can be realized as twodimensional arrays.
Scala does not directly support multi-dimensional arrays and provides various methods to process arrays in any
dimension. Following is the example of defining a two-dimensional array:
var myMatrix = ofDim[Int](3,3)
This is an array that has three elements each being an array of integers that has three elements. The code that
follows shows how one can process a multi-dimensional array:
import Array._
object Test {
def main(args: Array[String]) {
var myMatrix = ofDim[Int](3,3)
// build a matrix
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
myMatrix(i)(j) = j;
}
}
// Print two dimensional array
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
print(" " + myMatrix(i)(j));
}
println();
}
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
0 1 2
0 1 2
0 1 2
C:/>
Concatenate Arrays:
Following is the example, which makes use of concat() method to concatenate two arrays. You can pass more than
one array as arguments to concat() method.
import Array._
object Test {
TUTORIALS POINT
Simply Easy Learning
TUTORIALS POINT
Simply Easy Learning
C:/>
def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit
Copy one array to another. Equivalent to Java's System.arraycopy(src, srcPos, dest, destPos, length).
10
11
12
13
14
15
def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]
Returns a two-dimensional array containing values of a given function over ranges of integer values starting
from 0.
TUTORIALS POINT
Simply Easy Learning
CHAPTER
14
Scala Collections
cala has a rich set of collection library. Collections are containers of things. Those containers can be
sequenced, linear sets of items like List, Tuple, Option, Map, etc. The collections may have an arbitrary number of
elements or be bounded to zero or one element (e.g., Option).
Collections may be strict or lazy. Lazy collections have elements that may not consume memory until they are
accessed, like Ranges. Additionally, collections may be mutable (the contents of the reference can change)
or immutable (the thing that a reference refers to is never changed). Note that immutable collections may contain
mutable items.
For some problems, mutable collections work better, and for others, immutable collections work better. When in
doubt, it is better to start with an immutable collection and change it later if you need mutable ones.
This chapter gives details of the most commonly used collection types and most frequently used operations over
those collections.
SN
Scala Lists
Scala's List[T] is a linked list of type T.
Scala Sets
A set is a collection of pairwise different elements of the same type.
Scala Maps
A Map is a collection of key/value pairs. Any value can be retrieved based on its key.
Scala Tuples
Unlike an array or list, a tuple can hold objects with different types.
Scala Options
Option[T] provides a container for zero or one element of a given type.
Scala Iterators
An iterator is not a collection, but rather a way to access the elements of a collection one by one.
TUTORIALS POINT
Simply Easy Learning
Scala Lists
Scala Lists are quite similar to arrays which means, all the elements of a list have the same type, but there are two
important differences. First, lists are immutable, which means elements of a list cannot be changed by assignment.
Second, lists represent a linked list whereas arrays are flat.
The type of a list that has elements of type T is written as List[T]. For example, here are few lists defined for various
data types:
// List of Strings
val fruit: List[String] = List("apples", "oranges", "pears")
// 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)
)
All lists can be defined using two fundamental building blocks, a tail Nil and ::, which is pronounced cons. Nil also
represents the empty list. All the above lists can be defined as follows:
// List of Strings
val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
// List of Integers
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))
// Empty List.
val empty = Nil
// Two dimensional
val dim = (1 :: (0
(0 :: (1
(0 :: (0
list
:: (0 :: Nil))) ::
:: (0 :: Nil))) ::
:: (1 :: Nil))) :: Nil
Description
Head
Tail
This method returns a list consisting of all elements except the first.
isEmpty
TUTORIALS POINT
Simply Easy Learning
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Head of fruit : apples
Tail of fruit : List(oranges, pears)
Check if fruit is empty : false
Check if nums is empty : true
C:/>
Concatenating Lists:
You can use either ::: operator or List.:::() method or List.concat() method to add two or more lists. Following is
the example:
object Test {
def main(args: Array[String]) {
val fruit1 = "apples" :: ("oranges" :: ("pears" :: Nil))
val fruit2 = "mangoes" :: ("banana" :: Nil)
// use two or more lists with ::: operator
var fruit = fruit1 ::: fruit2
println( "fruit1 ::: fruit2 : " + fruit )
// use two lists with Set.:::() method
fruit = fruit1.:::(fruit2)
println( "fruit1.:::(fruit2) : " + fruit )
// pass two or more lists as arguments
fruit = List.concat(fruit1, fruit2)
println( "List.concat(fruit1, fruit2) : " + fruit
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
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)
C:/>
TUTORIALS POINT
Simply Easy Learning
// Repeats 2, 10 times.
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
fruit : List(apples, apples, apples)
num : List(2, 2, 2, 2, 2, 2, 2, 2, 2, 2)
C:/>
Tabulating a Function:
You can use a function along with List.tabulate() method to apply on all the elements of the list before tabulating
the list. Its arguments are just like those of List.fill: the first argument list gives the dimensions of the list to create,
and the second describes the elements of the list. The only difference is that instead of the elements being fixed,
they are computed from a function:
object Test {
def main(args: Array[String]) {
// Creates 5 elements using the given function.
val squares = List.tabulate(6)(n => n * n)
println( "squares : " + squares )
//
val mul = List.tabulate( 4,5 )( _ * _ )
println( "mul : " + mul )
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
squares : List(0, 1, 4, 9, 16, 25)
mul : List(List(0, 0, 0, 0, 0), List(0, 1, 2, 3, 4),
List(0, 2, 4, 6, 8), List(0, 3, 6, 9, 12))
C:/>
TUTORIALS POINT
Simply Easy Learning
10
11
12
TUTORIALS POINT
Simply Easy Learning
13
14
15
16
17
18
19
20
def head: A
Selects the first element of the list.
21
22
23
24
25
26
def last: A
Returns the last element.
27
28
29
30
def max: A
Finds the largest element.
31
def min: A
Finds the smallest element.
32
33
TUTORIALS POINT
Simply Easy Learning
35
36
37
def sum: A
Sums up the elements of this collection.
38
39
40
41
42
43
44
45
46
Scala Sets
Scala Set is a collection of pairwise different elements of the same type. In other words, a Set is a collection that
contains no duplicate elements. There are two kinds of Sets, the immutable and themutable. The difference
between mutable and immutable objects is that when an object is immutable, the object itself can't be changed.
By default, Scala uses the immutable Set. If you want to use the mutable Set, you'll have to import
scala.collection.mutable.Set class explicitly. If you want to use both mutable and immutable sets in the same,
then you can continue to refer to the immutable Set as Set but you can refer to the mutable Set as mutable.Set.
Following is the example to declare immutable Sets as follows:
// Empty set of integer type
var s : Set[Int] = Set()
// Set of integer type
var s : Set[Int] = Set(1,3,5,7)
or
TUTORIALS POINT
Simply Easy Learning
var s = Set(1,3,5,7)
While defining empty set, the type annotation is necessary as the system needs to assign a concrete type to
variable.
Description
Head
Tail
This method returns a set consisting of all elements except the first.
isEmpty
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Head of fruit : apples
Tail of fruit : Set(oranges, pears)
Check if fruit is empty : false
Check if nums is empty : true
C:/>
Concatenating Sets:
You can use either ++ operator or Set.++() method to concatenate two or more sets, but while adding sets it will
remove duplicate elements. Following is the example to concatenate two sets:
object Test {
def main(args: Array[String]) {
val fruit1 = Set("apples", "oranges", "pears")
val fruit2 = Set("mangoes", "banana")
// use two or more sets with ++ as operator
var fruit = fruit1 ++ fruit2
println( "fruit1 ++ fruit2 : " + fruit )
// use two sets with ++ as method
fruit = fruit1.++(fruit2)
println( "fruit1.++(fruit2) : " + fruit )
TUTORIALS POINT
Simply Easy Learning
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
fruit1 ++ fruit2 : Set(banana, apples, mangoes, pears, oranges)
fruit1.++(fruit2) : Set(banana, apples, mangoes, pears, oranges)
C:/>
TUTORIALS POINT
Simply Easy Learning
C:/>
10
11
def apply(elem: A)
Tests if some element is contained in this set.
12
13
14
15
16
17
TUTORIALS POINT
Simply Easy Learning
19
20
21
22
23
24
def head: A
Returns the first element of this immutable set.
25
26
27
28
29
def last: A
Returns the last element.
30
31
def max: A
Finds the largest element.
32
def min: A
Finds the smallest element.
33
34
35
def product: A
Returns the product of all elements of this immutable set with respect to the * operator in num.
36
37
TUTORIALS POINT
Simply Easy Learning
elements.
38
39
def sum: A
Returns the sum of all elements of this immutable set with respect to the + operator in num.
40
41
42
43
44
45
46
47
48
Scala Maps
Scala map is a collection of key/value pairs. Any value can be retrieved based on its key. Keys are unique in the
Map, but values need not be unique. Maps are also called Hash tables. There are two kinds of Maps,
the immutable and the mutable. The difference between mutable and immutable objects is that when an object is
immutable, the object itself can't be changed.
By default, Scala uses the immutable Map. If you want to use the mutable Set, you'll have to
importscala.collection.mutable.Map class explicitly. If you want to use both mutable and immutable Maps in the
same, then you can continue to refer to the immutable Map as Map but you can refer to the mutable set
as mutable.Map. Following is the example to declare immutable Maps as follows:
// 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")
While defining empty map, the type annotation is necessary as the system needs to assign a concrete type to
variable. If we want to add a key-value pair to a Map, we can use the operator + as follows:
A
A
A
A
+=
+=
+=
+=
('I'
('J'
('K'
('L'
->
->
->
->
1)
5)
10)
100)
TUTORIALS POINT
Simply Easy Learning
Description
keys
values
isEmpty
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
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
C:/>
Concatenating Maps
You can use either ++ operator or Map.++() method to concatenate two or more Maps, but while adding Maps it will
remove duplicate keys. Following is the example to concatenate two Maps:
object Test {
def main(args: Array[String]) {
val colors1 = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")
val colors2 = Map("blue" -> "#0033FF",
"yellow" -> "#FFFF00",
"red" -> "#FF0000")
// use two or more Maps with ++ as operator
var colors = colors1 ++ colors2
println( "colors1 ++ colors2 : " + colors )
TUTORIALS POINT
Simply Easy Learning
TUTORIALS POINT
Simply Easy Learning
10
TUTORIALS POINT
Simply Easy Learning
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
TUTORIALS POINT
Simply Easy Learning
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
Scala Tuples
Scala tuple combines a fixed number of items together so that they can be passed around as a whole. Unlike an
array or list, a tuple can hold objects with different types but they are also immutable. Here is an example of a tuple
holding an integer, a string, and the console:
val t = (1, "hello", Console)
Which is syntactic sugar (short cut) for the following:
TUTORIALS POINT
Simply Easy Learning
+ sum )
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Sum of elements: 10
C:/>
TUTORIALS POINT
Simply Easy Learning
Value = 1
C:/>
Convert to String:
You can use Tuple.toString() method to concatenate all the elements of the tuple into a string. Following is the
example to show the usage:
object Test {
def main(args: Array[String]) {
val t = new Tuple3(1, "hello", Console)
println("Concatenated String: " + t.toString() )
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Concatenated String: (1,hello,scala.Console$@281acd47)
C:/>
Scala Options
Scala Option[T] is a container for zero or one element of a given type. An Option[T] can be
eitherSome[T] or None object, which represents a missing value. For instance, the get method of Scala's Map
produces Some(value) if a value corresponding to a given key has been found, or None if the given key is not
defined in the Map. The Option type is used frequently in Scala programs and you can compare this to null value
available in Java which indicate no value. For example, the get method of java.util.HashMap returns either a value
stored in the HashMap, or null if no value was found.
Let's say we have a method that retrieves a record from the database based on a primary key:
def findPerson(key: Int): Option[Person]
TUTORIALS POINT
Simply Easy Learning
The method will return Some[Person] if the record is found but None if the record is not found. Let us see a real
example:
object Test {
def main(args: Array[String]) {
val capitals = Map("France" -> "Paris", "Japan" -> "Tokyo")
println("capitals.get( \"France\" ) : " + capitals.get( "France" ))
println("capitals.get( \"India\" ) : " + capitals.get( "India" ))
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
capitals.get( "France" ) : Some(Paris)
capitals.get( "India" ) : None
C:/>
The most common way to take optional values apart is through a pattern match. For instance:
object Test {
def main(args: Array[String]) {
val capitals = Map("France" -> "Paris", "Japan" -> "Tokyo")
println("show(capitals.get( \"Japan\")) : " +
show(capitals.get( "Japan")) )
println("show(capitals.get( \"India\")) : " +
show(capitals.get( "India")) )
}
def show(x: Option[String]) = x match {
case Some(s) => s
case None => "?"
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
show(capitals.get( "Japan")) : Tokyo
show(capitals.get( "India")) : ?
C:/>
TUTORIALS POINT
Simply Easy Learning
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
a.getOrElse(0): 5
b.getOrElse(10): 10
C:/>
def get: A
Returns the option's value.
TUTORIALS POINT
Simply Easy Learning
10
11
12
13
14
15
def orNull
Returns the option's value if it is nonempty, or null if it is empty.
Scala Iterators
An iterator is not a collection, but rather 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() will return the next element of the iterator and
advance the state of the iterator. You can find out whether there are more elements to return using
Iterator's it.hasNext method.
The most straightforward way to "step through" all the elements returned by an iterator is to use a while loop. Let us
see a real example:
object Test {
def main(args: Array[String]) {
val it = Iterator("a", "number", "of", "words")
while (it.hasNext){
println(it.next())
}
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
a
number
TUTORIALS POINT
Simply Easy Learning
of
words
C:/>
TUTORIALS POINT
Simply Easy Learning
def next(): A
Produces the next element of this iterator.
10
11
12
13
14
15
16
17
TUTORIALS POINT
Simply Easy Learning
18
19
20
21
22
23
24
25
26
27
28
def max: A
Finds the largest element. The iterator is at its end after this method returns.
29
def min: A
Finds the minumum element. The iterator is at its end after this method returns.
30
31
32
33
34
35
def product: A
Multiplies up the elements of this collection.
36
37
TUTORIALS POINT
Simply Easy Learning
38
39
40
def sum: A
Returns the sum of all elements of this traversable or iterator with respect to the + operator in num.
41
42
43
44
45
46
47
48
49
50
Example:
Following code snippet is a simple example to define all the above type of collections:
// Define List of integers.
val x = List(1,2,3,4)
// Define a set.
var x = Set(1,3,5,7)
// Define a map.
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)
// Create a tuple of two elements.
val x = (10, "Scala")
TUTORIALS POINT
Simply Easy Learning
// Define an option
val x:Option[Int] = Some(5)
TUTORIALS POINT
Simply Easy Learning
CHAPTER
15
Scala Classes & Objects
class is a blueprint for objects. Once you define a class, you can create objects from the class blueprint
with the keyword new. Following is a simple syntax to define a class in Scala:
class Point(xc: Int, yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
This class defines two variables x and y and a method: move, which does not return a value. Class variables are
called, fields of the class and methods are called class methods.
The class name works as a class constructor, which can take a number of parameters. The above code defines two
constructor arguments, xc and yc; they are both visible in the whole body of the class.
As mentioned earlier, you can create objects using a keyword new and then you can access class fields and
methods as shown below in the example:
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) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
object Test {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// Move to a new location
TUTORIALS POINT
Simply Easy Learning
pt.move(10, 10);
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Point x location : 20
Point y location : 30
C:/>
Extending a Class:
You can extend a base scala class in similar way you can do it in Java but there are two restrictions: method
overriding requires the override keyword, and only the primary constructor can pass parameters to the base
constructor. Let us extend our above class and add one more class method:
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
class Location(override val xc: Int, override val yc: Int,
val zc :Int) extends Point(xc, yc){
var z: Int = zc
def move(dx: Int, dy: Int, dz: Int)
x = x + dx
y = y + dy
z = z + dz
println ("Point x location : " +
println ("Point y location : " +
println ("Point z location : " +
}
x);
y);
z);
}
Such an extends clause has two effects: it makes class Location inherit all non-private members from class Point,
and it makes the type Location a subtype of the type Point class. So here the Point class is called superclass and
the class Location is called subclass. Extending a class and inheriting all the features of a parent class is
called inheritance but scala allows the inheritance from just one class only. Let us take complete example showing
inheirtance:
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) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
TUTORIALS POINT
Simply Easy Learning
x);
y);
z);
}
object Test {
def main(args: Array[String]) {
val loc = new Location(10, 20, 15);
// Move to a new location
loc.move(10, 10, 5);
}
}
Note that methods move and move do not override the corresponding definitions of move since they are different
definitions (for example, the former take two arguments while the latter take three arguments). When the above
code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Point x location : 20
Point y location : 30
Point z location : 20
C:/>
Singleton objects:
Scala is more object-oriented than Java because in Scala we cannot have static members. Instead, Scala
has singleton objects. A singleton is a class that can have only one instance, i.e., object. You create singleton
using the keyword object instead of class keyword. Since you can't instantiate a singleton object, you can't pass
parameters to the primary constructor. You already have seen all the examples using singleton objects where you
called Scala's main method. Following is the same example of showing singleton:
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) {
x = x + dx
y = y + dy
}
}
object Test {
def main(args: Array[String]) {
TUTORIALS POINT
Simply Easy Learning
TUTORIALS POINT
Simply Easy Learning
CHAPTER
16
Scala Traits
trait encapsulates method and field definitions, which can then be reused by mixing them into classes.
Unlike class inheritance, in which each class must inherit from just one superclass, a class can mix in any number
of traits.
Traits are used to define object types by specifying the signature of the supported methods. Scala also allows traits
to be partially implemented but traits may not have constructor parameters.
A trait definition looks just like a class definition except that it uses the keyword trait as follows:
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
This trait consists of two methods isEqual and isNotEqual. Here, we have not given any implementation for isEqual
where as another method has its implementation. Child classes extending a trait can give implementation for the unimplemented methods. So a trait is very similar to what we have abstract classes in Java. Below is a complete
example to show the concept of traits:
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
class Point(xc: Int, yc: Int) extends Equal {
var x: Int = xc
var y: Int = yc
def isEqual(obj: Any) =
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
}
object Test {
def main(args: Array[String]) {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotEqual(p2))
println(p1.isNotEqual(p3))
println(p1.isNotEqual(2))
TUTORIALS POINT
Simply Easy Learning
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
false
true
true
C:/>
If the behavior will not be reused, then make it a concrete class. It is not reusable behavior after all.
If it might be reused in multiple, unrelated classes, make it a trait. Only traits can be mixed into different parts of
the class hierarchy.
If you plan to distribute it in compiled form, and you expect outside groups to write classes inheriting from it, you
might lean towards using an abstract class.
TUTORIALS POINT
Simply Easy Learning
CHAPTER
17
Scala Pattern Matching
attern matching is the second most widely used feature of Scala, after function values and closures. Scala
provides great support for pattern matching for processing the messages.
A pattern match includes a sequence of alternatives, each starting with the keyword case. Each alternative
includes a pattern and one or more expressions, which will be evaluated if the pattern matches. An arrow symbol
=> separates the pattern from the expressions. Here is a small example, which shows how to match against an
integer value:
object Test {
def main(args: Array[String]) {
println(matchTest(3))
}
def matchTest(x: Int): String = x match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
many
C:/>
The block with the case statements defines a function, which maps integers to strings. The match keyword
provides a convenient way of applying a function (like the pattern matching function above) to an object. Following
is a second example, which matches a value against patterns of different types:
object Test {
def main(args: Array[String]) {
println(matchTest("two"))
println(matchTest("test"))
println(matchTest(1))
}
def matchTest(x: Any): Any = x match {
case 1 => "one"
TUTORIALS POINT
Simply Easy Learning
TUTORIALS POINT
Simply Easy Learning
TUTORIALS POINT
Simply Easy Learning
CHAPTER
18
Scala Regular Expressions
cala supports regular expressions through Regex class available in the scala.util.matching package. Let us
check an example where we will try to find out word Scala from a statement:
import scala.util.matching.Regex
object Test {
def main(args: Array[String]) {
val pattern = "Scala".r
val str = "Scala is Scalable and cool"
println(pattern findFirstIn str)
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Some(Scala)
C:/>
We create a String and call the r( ) method on it. Scala implicitly converts the String to a RichString and invokes that
method to get an instance of Regex. To find a first match of the regular expression, simply call
the findFirstIn() method. If instead of finding only the first occurrence we would like to find all occurrences of the
matching word, we can use the findAllIn( ) method and in case there are multiple Scala words available in the
target string, this will return a collection of all matching words.
You can make use of the mkString( ) method to concatenate the resulting list and you can use a pipe (|) to search
small and capital case of Scala and you can use Regex constructor instead or r() method to create a pattern as
follows:
import scala.util.matching.Regex
object Test {
def main(args: Array[String]) {
val pattern = new Regex("(S|s)cala")
val str = "Scala is scalable and cool"
println((pattern findAllIn str).mkString(","))
}
TUTORIALS POINT
Simply Easy Learning
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Scala,scala
C:/>
If you would like to replace matching text, we can use replaceFirstIn( ) to replace the first match orreplaceAllIn(
) to replace all occurrences as follows:
object Test {
def main(args: Array[String]) {
val pattern = "(S|s)cala".r
val str = "Scala is scalable and cool"
println(pattern replaceFirstIn(str, "Java"))
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
C:/>scala Test
Java is scalable and cool
C:/>
Matches
Matches any single character except newline. Using m option allows it to match
newline as well.
[...]
[^...]
\\A
\\z
\\Z
re*
re+
TUTORIALS POINT
Simply Easy Learning
re?
re{ n}
re{ n,}
re{ n, m}
a|b
Matches either a or b.
(re)
(?: re)
(?> re)
\\w
\\W
\\s
\\S
Matches nonwhitespace.
\\d
\\D
Matches nondigits.
\\A
\\Z
\\z
\\G
\\n
\\b
Matches word boundaries when outside brackets. Matches backspace (0x08) when
inside brackets.
\\B
\\Q
\\E
Regular-expression Examples:
Example
Description
[Rr]uby
rub[ye]
[aeiou]
TUTORIALS POINT
Simply Easy Learning
[0-9]
[a-z]
[A-Z]
[a-zA-Z0-9]
[^aeiou]
[^0-9]
\\d
\\D
\\s
\\S
\\w
\\W
ruby?
ruby*
ruby+
\\d{3}
\\d{3,}
\\d{3,5}
Match 3, 4, or 5 digits
\\D\\d+
(\\D\\d)+/
([Rr]uby(, )?)+
Note that every backslash appears twice in the string above. This is because in Java and Scala a single backslash
is an escape character in a string literal, not a regular character that shows up in the string. So instead of .\. you
need to write .\\. to get a single backslash in the string. Check the following example:
import scala.util.matching.Regex
object Test {
def main(args: Array[String]) {
val pattern = new Regex("abl[ae]\\d+")
val str = "ablaw is able1 and cool"
println((pattern findAllIn str).mkString(","))
}
}
When the above code is compiled and executed, it produces the following result:
C:/>scalac Test.scala
TUTORIALS POINT
Simply Easy Learning
C:/>scala Test
able1
C:/>
TUTORIALS POINT
Simply Easy Learning
CHAPTER
19
Scala Exception Handling
calas exceptions work like exceptions in many other languages like Java. Instead of returning a value in
the normal way, a method can terminate by throwing an exception. However, Scala doesn't actually have checked
exceptions.
When you want to handle exceptions, you use a try{...}catch{...} block like you would in Java except that the catch
block uses matching to identify and handle the exceptions.
Throwing exceptions:
Throwing an exception looks the same as in Java. You create an exception object and then you throw it with
the throw keyword:
throw new IllegalArgumentException
Catching exceptions:
Scala allows you to try/catch any exception in a single block and then perform pattern matching against it
using case blocks as shown below:
import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
object Test {
def main(args: Array[String]) {
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException =>{
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
}
}
}
When the above code is compiled and executed, it produces the following result:
TUTORIALS POINT
Simply Easy Learning
C:/>scalac Test.scala
C:/>scala Test
Missing file exception
C:/>
The behavior of this try-catch expression is the same as in other languages with exceptions. The body is executed,
and if it throws an exception, each catch clause is tried in turn.
TUTORIALS POINT
Simply Easy Learning
CHAPTER
20
Scala Extractors
n extractor in Scala is an object that has a method called unapply as one of its members. The purpose
of that unapply method is to match a value and take it apart. Often, the extractor object also defines a dual
method apply for building values, but this is not required.
Following example shows an extractor object for email addresses:
object Test {
def main(args: Array[String]) {
println ("Apply method : " + apply("Zara", "gmail.com"));
println ("Unapply method : " + unapply("[email protected]"));
println ("Unapply method : " + unapply("Zara Ali"));
}
// The injection method (optional)
def apply(user: String, domain: String) = {
user +"@"+ domain
}
// The extraction method (mandatory)
def unapply(str: String): Option[(String, String)] = {
val parts = str split "@"
if (parts.length == 2){
Some(parts(0), parts(1))
}else{
None
}
}
}
This object defines both apply and unapply methods. The apply method has the same meaning as always: it turns
Test into an object that can be applied to arguments in parentheses in the same way a method is applied. So you
can write Test("Zara", "gmail.com") to construct the string "[email protected]".
The unapply method is what turns Test class into an extractor and it reverses the construction process of apply.
Where apply takes two strings and forms an email address string out of them, unapply takes an email address and
returns potentially two strings: the user and the domain of the address.
The unapply must also handle the case where the given string is not an email address. That's why unapply returns
an Option-type over pairs of strings. Its result is either Some(user, domain) if the string str is an email address
with the given user and domain parts, or None, if str is not an email address. Here are some examples:
TUTORIALS POINT
Simply Easy Learning
TUTORIALS POINT
Simply Easy Learning
CHAPTER
21
Scala Files I/O
cala is open to make use of any Java objects and java.io.File is one of the objects which can be used in
Scala programming to read and write files. Following is an example of writing to a file:
import java.io._
object Test {
def main(args: Array[String]) {
val writer = new PrintWriter(new File("test.txt" ))
writer.write("Hello Scala")
writer.close()
}
}
When the above code is compiled and executed, it creates a file with "Hello Scala" content which you can check
yourself.
C:/>scalac Test.scala
C:/>scala Test
C:/>
TUTORIALS POINT
Simply Easy Learning
C:/>scala Test
scala Test
Please enter your input : Scala is great
Thanks, you just typed: Scala is great
C:/>
TUTORIALS POINT
Simply Easy Learning